@openstax/ts-utils 1.33.1 → 1.34.0

package/dist/cjs/config/awsParameterConfig.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.awsParameterConfig = void 0;
-const client_ssm_1 = require("@aws-sdk/client-ssm");
-const assertions_1 = require("../assertions");
-const ssmService_1 = require("../aws/ssmService");
-const resolveConfigValue_1 = require("./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
- */
-const awsParameterConfig = (parameterName) => {
-    return async () => {
-        const command = new client_ssm_1.GetParameterCommand({ Name: await (0, resolveConfigValue_1.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 (0, ssmService_1.ssmService)().send(command);
-        const parameter = (0, assertions_1.assertDefined)(response.Parameter, `aws GetParameter response missing Parameter key for ${parameterName}"`);
-        return (0, assertions_1.assertDefined)(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${parameterName}"`);
-    };
-};
-exports.awsParameterConfig = awsParameterConfig;

package/dist/cjs/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/cjs/config/envConfig.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.envConfig = exports.ENV_BUILD_CONFIGS = void 0;
-const resolveConfigValue_1 = require("./resolveConfigValue");
-/**
- * A list of environment variables that were requested at build time. Used by webpack to
- * capture build-time environment variables values.
- */
-exports.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') };
- */
-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') {
-        exports.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 (0, resolveConfigValue_1.resolveConfigValue)(defaultValue);
-            }
-        }
-        else {
-            return value;
-        }
-    };
-};
-exports.envConfig = envConfig;

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

@@ -1,48 +0,0 @@
-/**
- * A simple type alias for a string that represents a configuration value. Currently only string values are supported to maintain compatibility with environment variables, but this type is future proofing against allowing other types like `number` as possible config values.
- */
-export type ConfigValue = string;
-/**
- * A configuration object that may contain nested configuration objects or configuration values.
- */
-export type Config = {
-    [key: string]: Config | ConfigValue;
-};
-/**
- * Either a function that returns a `ConfigValue` or a `Promise` that resolves to a `ConfigValue`,
- * or just a `ConfigValue`.
- */
-export type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
-/**
- * A configuration object that may contain nested configuration objects or configuration value providers.
- */
-export type ConfigProvider = {
-    [key: string]: ConfigProvider | ConfigValueProvider;
-};
-/**
- * Conditional type that resolves to the type of configuration object for the given configuration
- * provider. Also resolves to a config value type if the given type is a config value.
- */
-export type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T extends ConfigProvider ? {
-    [key in keyof T]: ConfigForConfigProvider<T[key]>;
-} : T extends ConfigValueProvider<infer R> ? R : never;
-/**
- * Conditional type that resolves to the `ConfigProvider` type for the given configuration
- * type (`ConfigValue` or `Config`). The resulting type is either a `ConfigValueProvider` or
- * a `ConfigProvider`.
- */
-export type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
-    [key in keyof T]: ConfigProviderForConfig<T[key]>;
-} : never;
-export * from './resolveConfigValue';
-/**
- * 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 declare const stubConfig: <V extends ConfigValue>(configValue: V) => ConfigValueProvider<V>;
-export * from './envConfig';
-export * from './replaceConfig';
-export * from './awsParameterConfig';
-export * from './lambdaParameterConfig';

package/dist/cjs/config/index.js

@@ -1,35 +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 });
-exports.stubConfig = void 0;
-__exportStar(require("./resolveConfigValue"), exports);
-/*
- * ===========
- * 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') };
- */
-const stubConfig = (configValue) => configValue;
-exports.stubConfig = stubConfig;
-__exportStar(require("./envConfig"), exports);
-__exportStar(require("./replaceConfig"), exports);
-__exportStar(require("./awsParameterConfig"), exports);
-__exportStar(require("./lambdaParameterConfig"), exports);

package/dist/cjs/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/cjs/config/lambdaParameterConfig.js

@@ -1,45 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lambdaParameterConfig = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const assertions_1 = require("../assertions");
-const helpers_1 = require("../misc/helpers");
-const envConfig_1 = require("./envConfig");
-const _1 = require(".");
-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
- */
-const lambdaParameterConfig = (parameterName) => async () => {
-    const token = await (0, _1.resolveConfigValue)((0, envConfig_1.envConfig)('AWS_SESSION_TOKEN', 'runtime'));
-    const name = await (0, _1.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 = (0, helpers_1.retryWithDelay)(() => (0, node_fetch_1.default)(lambdaExtensionUrl));
-    }
-    await lambdaExtensionReadyPromise;
-    const resp = await (0, helpers_1.retryWithDelay)(() => (0, node_fetch_1.default)(
-    // 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 = (0, assertions_1.assertDefined)(response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`);
-        return (0, assertions_1.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}`);
-    }
-};
-exports.lambdaParameterConfig = lambdaParameterConfig;

package/dist/cjs/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/cjs/config/replaceConfig.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceConfig = void 0;
-const resolveConfigValue_1 = require("./resolveConfigValue");
-/**
- * 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
- */
-const replaceConfig = (base, replacements) => {
-    return async () => {
-        const resolved = await Promise.all(Object.entries(replacements)
-            .map(async ([token, replacement]) => [token, await (0, resolveConfigValue_1.resolveConfigValue)(replacement)]));
-        return resolved.reduce((result, [token, replacement]) => result.replace(token, replacement), await (0, resolveConfigValue_1.resolveConfigValue)(base));
-    };
-};
-exports.replaceConfig = replaceConfig;

package/dist/cjs/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/cjs/config/resolveConfigValue.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveConfigValue = void 0;
-/**
- * resolves a config value into a string, to be used inside of things that are provided configurations
- */
-const resolveConfigValue = async (provider) => {
-    return typeof provider === 'function'
-        ? await provider()
-        : provider;
-};
-exports.resolveConfigValue = resolveConfigValue;

package/dist/cjs/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/cjs/errors/index.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConflictError = exports.SessionExpiredError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.InvalidRequestError = exports.isAppError = void 0;
-/*
- * if code is split into multiple bundles, sometimes each bundle
- * will get its own definition of this module and then instanceof checks
- * are unreliable, this provides a way to reliably check the error types
- *
- * eg this will always work:
- *   InvalidRequestError.matches(error);
- *
- * eg this might not work if you have code splitting:
- *   error instanceof InvalidRequestError
- *
- */
-const errorIsType = (t) => (e) => e instanceof Error
-    && e.constructor.TYPE === t.TYPE;
-/**
- * Returns true if the error is defined in this library
- */
-const isAppError = (e) => e instanceof Error
-    && typeof e.constructor.TYPE === 'string';
-exports.isAppError = isAppError;
-/**
- * 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
- */
-class InvalidRequestError extends Error {
-    constructor(message) {
-        super(message || InvalidRequestError.TYPE);
-    }
-}
-exports.InvalidRequestError = InvalidRequestError;
-InvalidRequestError.TYPE = 'InvalidRequestError';
-InvalidRequestError.matches = errorIsType(InvalidRequestError);
-/**
- * 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
- */
-class ValidationError extends Error {
-    constructor(data) {
-        super(InvalidRequestError.TYPE);
-        this.data = data;
-    }
-    getData() { return this.data; }
-}
-exports.ValidationError = ValidationError;
-ValidationError.TYPE = 'ValidationError';
-ValidationError.matches = errorIsType(ValidationError);
-/**
- * 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
- */
-class UnauthorizedError extends Error {
-    constructor(message) {
-        super(message || UnauthorizedError.TYPE);
-    }
-}
-exports.UnauthorizedError = UnauthorizedError;
-UnauthorizedError.TYPE = 'UnauthorizedError';
-UnauthorizedError.matches = errorIsType(UnauthorizedError);
-/**
- * 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
- */
-class ForbiddenError extends Error {
-    constructor(message) {
-        super(message || ForbiddenError.TYPE);
-    }
-}
-exports.ForbiddenError = ForbiddenError;
-ForbiddenError.TYPE = 'ForbiddenError';
-ForbiddenError.matches = errorIsType(ForbiddenError);
-/**
- * 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
- */
-class NotFoundError extends Error {
-    constructor(message) {
-        super(message || NotFoundError.TYPE);
-    }
-}
-exports.NotFoundError = NotFoundError;
-NotFoundError.TYPE = 'NotFoundError';
-NotFoundError.matches = errorIsType(NotFoundError);
-/**
- * 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
- */
-class SessionExpiredError extends Error {
-    constructor(message) {
-        super(message || SessionExpiredError.TYPE);
-    }
-}
-exports.SessionExpiredError = SessionExpiredError;
-SessionExpiredError.TYPE = 'SessionExpiredError';
-SessionExpiredError.matches = errorIsType(SessionExpiredError);
-/**
- * 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
- */
-class ConflictError extends Error {
-    constructor(message) {
-        super(message || ConflictError.TYPE);
-    }
-}
-exports.ConflictError = ConflictError;
-ConflictError.TYPE = 'ConflictError';
-ConflictError.matches = errorIsType(ConflictError);

package/dist/cjs/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/cjs/fetch/fetchStatusRetry.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchStatusRetry = void 0;
-const helpers_1 = require("../misc/helpers");
-const fetchStatusRetry = (base, options) => {
-    return (...params) => (0, helpers_1.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);
-};
-exports.fetchStatusRetry = fetchStatusRetry;

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