@openstax/ts-utils 1.33.1 → 1.34.0

package/dist/cjs/types.d.ts

@@ -1,31 +0,0 @@
-/**
- * Returns the literal type `'yes'` if the first generic tuple array is a prefix of the second,
- * the `'no'` literal type otherwise. Can be used in conditional types, e.g.
- *
- * `type WillBeString = TupleExtends<[1,2], [1,2,3]> extends 'yes' ? string : number;`
- *
- * There may be a better way to do this; `T1 extends T2` doesn't work
- */
-export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
-/**
- * unions each member of the tuple
- */
-export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
-/**
- * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
- * @deprecated use TypeScript builtin Awaited instead:
- * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements
- */
-export type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
-/**
- * turns `thing | thing2` into `thing & thing2`
- * @see https://stackoverflow.com/a/50375286/14809536
- */
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-/**
- * make certain fields required
- * @see https://stackoverflow.com/a/69328045/14809536
- */
-export type WithRequired<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};

package/dist/cjs/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,89 +0,0 @@
-export type AssertionFailed = string | Error | (() => never) | undefined;
-export declare const doThrow: (failed: AssertionFailed) => never;
-/**
- * Asserts that the given value is true.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
- * @returns the value that was asserted
- */
-export declare const assertTrue: <X>(x: X, failed?: AssertionFailed) => X & true;
-/**
- * Asserts that the given value is false.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
- * @returns the value that was asserted
- */
-export declare const assertFalse: <X>(x: X, failed?: AssertionFailed) => X & false;
-/**
- * Asserts that the given value is defined.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
- * @returns the value that was asserted, with a type that excludes undefined
- */
-export declare const assertDefined: <X>(x: X, failed?: AssertionFailed) => Exclude<X, undefined>;
-/**
- * Asserts that the given value is a string.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
- * @returns the value that was asserted
- */
-export declare const assertString: <X>(x: X, failed?: AssertionFailed) => string;
-/**
- * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
- *
- * @param thing The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
- * @returns the value that was asserted
- */
-export declare const assertNotNaN: <T>(thing: T, failed?: AssertionFailed) => T;
-/**
- * @deprecated use assertNotNaN instead
- */
-export declare const notNaN: <T>(thing: T, failed?: AssertionFailed) => T;
-/**
- * Asserts that the first argument is an instance of the second.
- *
- * @param thing The value to assert.
- * @param constructable The class to check against.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
- * @returns the value that was asserted
- */
-export declare const assertInstanceOf: <T>(thing: any, constructable: Function & {
-    new (...args: any[]): T;
-}, failed?: AssertionFailed) => T;
-/**
- * Asserts that the error in the first argument is an instance of the error given as the
- * second argument
- *
- * @param thing The value to assert.
- * @param constructable The error class to check against.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
- * @returns the value that was asserted
- * @throws the original error if the check fails
- * @see assertInstanceOf
- */
-export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & {
-    new (...args: any[]): T;
-}) => T;

package/dist/esm/aws/ssmService.d.ts

@@ -1,5 +0,0 @@
-import { SSM } from '@aws-sdk/client-ssm';
-/**
- * A memoized instance of the AWS SSM client.
- */
-export declare const ssmService: () => SSM;

package/dist/esm/aws/ssmService.js

@@ -1,6 +0,0 @@
-import { SSM } from '@aws-sdk/client-ssm';
-import { once } from '..';
-/**
- * A memoized instance of the AWS SSM client.
- */
-export const ssmService = once(() => new SSM({ apiVersion: '2012-08-10' }));

package/dist/esm/config/awsParameterConfig.d.ts

@@ -1,10 +0,0 @@
-import { ConfigValueProvider } from '.';
-/**
- * Returns a value from the AWS Parameter Store.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/awsParameterConfig.js

@@ -1,22 +0,0 @@
-import { GetParameterCommand } from '@aws-sdk/client-ssm';
-import { assertDefined } from '../assertions';
-import { ssmService } from '../aws/ssmService';
-import { resolveConfigValue } from './resolveConfigValue';
-/**
- * Returns a value from the AWS Parameter Store.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export const awsParameterConfig = (parameterName) => {
-    return async () => {
-        const command = new GetParameterCommand({ Name: await resolveConfigValue(parameterName), WithDecryption: true });
-        // send() throws ParameterNotFound if the parameter is missing,
-        // so it's not clear what missing Parameter or Value mean
-        const response = await ssmService().send(command);
-        const parameter = assertDefined(response.Parameter, `aws GetParameter response missing Parameter key for ${parameterName}"`);
-        return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${parameterName}"`);
-    };
-};

package/dist/esm/config/envConfig.d.ts

@@ -1,24 +0,0 @@
-import type { ConfigValueProvider } from '.';
-/**
- * A list of environment variables that were requested at build time. Used by webpack to
- * capture build-time environment variables values.
- */
-export declare const ENV_BUILD_CONFIGS: string[];
-/**
- * Returns an environment variable from the process environment. Depending on the `type` in the
- * call to get the variable, the variable's value may be what it was at build time, not at runtime.
- * The return value is not the variable value itself, but rather a provider that has to be called
- * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
- * because someone else later needs to call the provider to get the value -- that call may explode,
- * but this one won't).
- *
- * @param name The name of the environment variable to retrieve.
- * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
- * variable as it was set at build time (webpack is connected here to make this possible). This
- * argument can also be `'runtime'` in which case the value at build time is ignored and the
- * variable is pulled live from `process.env`.
- * @param [defaultValue] The default value to use if the variable is not found.
- *
- * @example const config = { configValue: envConfig('environment_variable_name') };
- */
-export declare const envConfig: (name: string, type?: "build" | "runtime", defaultValue?: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/envConfig.js

@@ -1,53 +0,0 @@
-import { resolveConfigValue } from './resolveConfigValue';
-/**
- * A list of environment variables that were requested at build time. Used by webpack to
- * capture build-time environment variables values.
- */
-export const ENV_BUILD_CONFIGS = [];
-/**
- * Returns an environment variable from the process environment. Depending on the `type` in the
- * call to get the variable, the variable's value may be what it was at build time, not at runtime.
- * The return value is not the variable value itself, but rather a provider that has to be called
- * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
- * because someone else later needs to call the provider to get the value -- that call may explode,
- * but this one won't).
- *
- * @param name The name of the environment variable to retrieve.
- * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
- * variable as it was set at build time (webpack is connected here to make this possible). This
- * argument can also be `'runtime'` in which case the value at build time is ignored and the
- * variable is pulled live from `process.env`.
- * @param [defaultValue] The default value to use if the variable is not found.
- *
- * @example const config = { configValue: envConfig('environment_variable_name') };
- */
-export const envConfig = (name, type, defaultValue) => {
-    // this doesn't use a default parameter value because of a:
-    //   "Regular parameters should not come after default parameters."
-    // error that occurs when the defaultValue optional default of `undefined`
-    // gets optimized out, causing a problem in cloudfront functions.
-    type !== null && type !== void 0 ? type : (type = 'build');
-    if (type === 'build') {
-        ENV_BUILD_CONFIGS.push(name);
-    }
-    return () => {
-        /*global __PROCESS_ENV*/
-        // @ts-ignore - hack to get around the way webpack/define works
-        // - https://github.com/webpack/webpack/issues/14800
-        // - https://github.com/webpack/webpack/issues/5392
-        // also, spread operator not supported in cloudfront functions
-        const envs = Object.assign({}, process.env, typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {});
-        const value = envs[name];
-        if (value === undefined) {
-            if (defaultValue === undefined) {
-                throw new Error(`expected to find environment variable with name: ${name}`);
-            }
-            else {
-                return resolveConfigValue(defaultValue);
-            }
-        }
-        else {
-            return value;
-        }
-    };
-};

package/dist/esm/config/index.js

@@ -1,17 +0,0 @@
-export * from './resolveConfigValue';
-/*
- * ===========
- * re-usable config providers
- * ===========
- * */
-/**
- * stub, mostly for testing. sometimes it helps please typescript to use this if you have
- * two configs you want to have the same type but one is a fixed string and one is a complicated provider
- *
- * @example const config = { configValue: stubConfig('just-a-string') };
- */
-export const stubConfig = (configValue) => configValue;
-export * from './envConfig';
-export * from './replaceConfig';
-export * from './awsParameterConfig';
-export * from './lambdaParameterConfig';

package/dist/esm/config/lambdaParameterConfig.d.ts

@@ -1,12 +0,0 @@
-import { ConfigValueProvider } from '.';
-/**
- * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
- * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
- * This extension has built-in caching for requested parameters.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export declare const lambdaParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/lambdaParameterConfig.js

@@ -1,38 +0,0 @@
-import fetch from 'node-fetch';
-import { assertDefined } from '../assertions';
-import { retryWithDelay } from '../misc/helpers';
-import { envConfig } from './envConfig';
-import { resolveConfigValue } from '.';
-const lambdaExtensionUrl = 'http://localhost:2773';
-let lambdaExtensionReadyPromise;
-/**
- * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
- * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
- * This extension has built-in caching for requested parameters.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export const lambdaParameterConfig = (parameterName) => async () => {
-    const token = await resolveConfigValue(envConfig('AWS_SESSION_TOKEN', 'runtime'));
-    const name = await resolveConfigValue(parameterName);
-    if (!lambdaExtensionReadyPromise) {
-        // This request will return 400 Bad Request,
-        // but we only care that it'll block until the extension is ready
-        lambdaExtensionReadyPromise = retryWithDelay(() => fetch(lambdaExtensionUrl));
-    }
-    await lambdaExtensionReadyPromise;
-    const resp = await retryWithDelay(() => fetch(
-    // Port 2773 is the default port for the extension
-    `${lambdaExtensionUrl}/systemsmanager/parameters/get?name=${name}&withDecryption=true`, { headers: { 'X-Aws-Parameters-Secrets-Token': token } }));
-    if (resp.ok) {
-        const response = await resp.json();
-        const parameter = assertDefined(response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`);
-        return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${name}"`);
-    }
-    else {
-        throw new Error(`HTTP Error Response ${resp.status} ${resp.statusText} while fetching parameter ${name}`);
-    }
-};

package/dist/esm/config/replaceConfig.d.ts

@@ -1,14 +0,0 @@
-import { ConfigValueProvider } from '.';
-/**
- * Substitutes configuration values into a provided string.
- * Performs a string substitution using configuration values
- * @param base The string into which substitutions will be made; contains tokens that are
- * referenced in the `replacements` argument.
- * @param replacements A map of tokens to configuration value providers. The providers are
- * resolved and the values are substituted into the `base` string, replacing the tokens.
- * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
- * @returns the string after substitution is complete
- */
-export declare const replaceConfig: (base: ConfigValueProvider<string>, replacements: {
-    [token: string]: ConfigValueProvider<string>;
-}) => ConfigValueProvider<string>;

package/dist/esm/config/resolveConfigValue.d.ts

@@ -1,5 +0,0 @@
-import type { ConfigValue, ConfigValueProvider } from '.';
-/**
- * resolves a config value into a string, to be used inside of things that are provided configurations
- */
-export declare const resolveConfigValue: <V extends ConfigValue>(provider: ConfigValueProvider<V>) => Promise<V>;

package/dist/esm/config/resolveConfigValue.js

@@ -1,8 +0,0 @@
-/**
- * resolves a config value into a string, to be used inside of things that are provided configurations
- */
-export const resolveConfigValue = async (provider) => {
-    return typeof provider === 'function'
-        ? await provider()
-        : provider;
-};

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

@@ -1,88 +0,0 @@
-import type { JsonCompatibleStruct } from '../routing';
-/**
- * Returns true if the error is defined in this library
- */
-export declare const isAppError: (e: any) => e is Error & {
-    constructor: {
-        TYPE: string;
-    };
-};
-/**
- * Invalid request error
- *
- * `InvalidRequestError.matches(error)` is a reliable way to check if an error is an
- * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class InvalidRequestError extends Error {
-    static readonly TYPE = "InvalidRequestError";
-    static matches: (e: any) => e is typeof InvalidRequestError;
-    constructor(message?: string);
-}
-/**
- * Validation Error
- *
- * `ValidationError.matches(error)` is a reliable way to check if an error is an
- * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class ValidationError extends Error {
-    static readonly TYPE = "ValidationError";
-    static matches: (e: any) => e is typeof ValidationError;
-    private data;
-    constructor(data: JsonCompatibleStruct);
-    getData(): JsonCompatibleStruct;
-}
-/**
- * Unauthorized error
- *
- * `UnauthorizedError.matches(error)` is a reliable way to check if an error is an
- * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class UnauthorizedError extends Error {
-    static readonly TYPE = "UnauthorizedError";
-    static matches: (e: any) => e is typeof UnauthorizedError;
-    constructor(message?: string);
-}
-/**
- * Forbidden error
- *
- * `ForbiddenError.matches(error)` is a reliable way to check if an error is a
- * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class ForbiddenError extends Error {
-    static readonly TYPE = "ForbiddenError";
-    static matches: (e: any) => e is typeof ForbiddenError;
-    constructor(message?: string);
-}
-/**
- * Not found error
- *
- * `NotFoundError.matches(error)` is a reliable way to check if an error is a
- * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class NotFoundError extends Error {
-    static readonly TYPE = "NotFoundError";
-    static matches: (e: any) => e is typeof NotFoundError;
-    constructor(message?: string);
-}
-/**
- * Session expired error
- *
- * `SessionExpiredError.matches(error)` is a reliable way to check if an error is a
- * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class SessionExpiredError extends Error {
-    static readonly TYPE = "SessionExpiredError";
-    static matches: (e: any) => e is typeof SessionExpiredError;
-    constructor(message?: string);
-}
-/**
- * Conflict error
- *
- * `ConflictError.matches(error)` is a reliable way to check if an error is a
- * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
- */
-export declare class ConflictError extends Error {
-    static readonly TYPE = "ConflictError";
-    static matches: (e: any) => e is typeof ConflictError;
-    constructor(message?: string);
-}

package/dist/esm/fetch/fetchStatusRetry.d.ts

@@ -1,8 +0,0 @@
-import { RetryOptions } from '../misc/helpers';
-import { GenericFetch } from '.';
-interface Options extends RetryOptions {
-    status?: number[];
-    timeout?: number;
-}
-export declare const fetchStatusRetry: (base: GenericFetch, options: Options) => GenericFetch;
-export {};

package/dist/esm/fetch/fetchStatusRetry.js

@@ -1,23 +0,0 @@
-import { retryWithDelay } from '../misc/helpers';
-export const fetchStatusRetry = (base, options) => {
-    return (...params) => retryWithDelay(() => {
-        const fetchPromise = base(...params).then(r => {
-            var _a;
-            if ((_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status)) {
-                return r.text().then(text => {
-                    throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
-                });
-            }
-            return r;
-        });
-        if (options.timeout) {
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => {
-                    reject(new Error(`fetch timeout after ${options.timeout}ms: ${params[0]}`));
-                }, options.timeout);
-            });
-            return Promise.race([fetchPromise, timeoutPromise]);
-        }
-        return fetchPromise;
-    }, options);
-};

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

@@ -1,64 +0,0 @@
-import { METHOD } from '../routing';
-export declare enum FetchStateType {
-    SUCCESS = "success",
-    ERROR = "error",
-    LOADING = "loading",
-    IDLE = "idle"
-}
-export type FetchState<D, E> = FetchStateLoading<D> | FetchStateError<D, E> | FetchStateSuccess<D> | FetchStateIdle;
-type FetchStateLoading<D> = {
-    type: FetchStateType.LOADING;
-    data?: D;
-};
-type FetchStateError<D, E> = {
-    type: FetchStateType.ERROR;
-    data?: D;
-    error: E;
-};
-type FetchStateSuccess<D> = {
-    type: FetchStateType.SUCCESS;
-    data: D;
-};
-type FetchStateIdle = {
-    type: FetchStateType.IDLE;
-};
-export declare const fetchLoading: <D, E>(previous?: FetchState<D, E>) => FetchStateLoading<D>;
-export declare const fetchError: <D, E>(error: E, previous?: FetchState<D, E>) => FetchStateError<D, E>;
-export declare const fetchSuccess: <D>(data: D) => FetchStateSuccess<D>;
-export declare const fetchIdle: () => FetchStateIdle;
-export declare const stateHasData: <D, E>(state: {
-    type: FetchStateType;
-    data?: D;
-    error?: E;
-}) => state is {
-    type: FetchStateType;
-    data: D;
-};
-export declare const stateHasError: <D, E>(state: {
-    type: FetchStateType;
-    data?: D;
-    error?: E;
-}) => state is {
-    type: FetchStateType;
-    error: E;
-};
-export type FetchConfig = {
-    credentials?: 'include' | 'omit' | 'same-origin';
-    method?: METHOD;
-    body?: string;
-    headers?: {
-        [key: string]: string;
-    };
-};
-type Headers = {
-    get: (name: string) => string | null;
-};
-export type Response = {
-    status: number;
-    headers: Headers;
-    json: () => Promise<any>;
-    text: () => Promise<string>;
-};
-export type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> = (url: string, fetchConfig?: C) => Promise<R>;
-export type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;
-export {};

package/dist/esm/fetch/index.js

@@ -1,46 +0,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.
- * */
-export var FetchStateType;
-(function (FetchStateType) {
-    FetchStateType["SUCCESS"] = "success";
-    FetchStateType["ERROR"] = "error";
-    FetchStateType["LOADING"] = "loading";
-    FetchStateType["IDLE"] = "idle";
-})(FetchStateType || (FetchStateType = {}));
-/*
- * keeps existing data but sets the new status
- *
- * const state = fetchLoading(previousState)
- * */
-export const fetchLoading = (previous) => ({ type: FetchStateType.LOADING, ...(previous && 'data' in previous ? { data: previous.data } : {}) });
-/*
- * keeps existing data but sets the new status and error value
- *
- * const state = fetchError(error, previousState)
- * */
-export const fetchError = (error, previous) => ({ ...previous, type: FetchStateType.ERROR, error });
-/*
- * formats data with success type
- *
- * const state = fetchSuccess(newData)
- * */
-export const fetchSuccess = (data) => ({ type: FetchStateType.SUCCESS, data });
-/*
- * formats data with idle type
- *
- * const state = fetchIdle(newData)
- * */
-export const fetchIdle = () => ({ type: FetchStateType.IDLE });
-/*
- * guard for checking if the state has result data, it might be true for any state type.
- * */
-export const stateHasData = (state) => 'data' in state;
-/*
- * guard for checking if the state has an error, it might be true for error or loading states.
- * */
-export const stateHasError = (state) => 'error' in state;

package/dist/esm/guards/index.js

@@ -1,36 +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 const isDefined = (x) => 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 const isNotNull = (x) => 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 const isNumber = (x) => typeof x === '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 const isPlainObject = (thing) => thing instanceof Object && thing.__proto__.constructor.name === 'Object';
-/**
- * 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 const ifDefined = (x, d) => isDefined(x) ? x : d;

package/dist/esm/index.d.ts

@@ -1,4 +0,0 @@
-export * from './misc/partitionSequence';
-export * from './misc/helpers';
-export * from './misc/merge';
-export * from './misc/hashValue';

package/dist/esm/index.js

@@ -1,4 +0,0 @@
-export * from './misc/partitionSequence';
-export * from './misc/helpers';
-export * from './misc/merge';
-export * from './misc/hashValue';