@restnfeel/agentc-starter-kit/dist/server.esm/node_modules/p-retry/index.js

한국어 기업용 CMS 모듈 - Task Master AI와 함께 빠르게 웹사이트를 구현할 수 있는 재사용 가능한 컴포넌트 시스템

"use client";
import { __module as pRetry } from '../../_virtual/index19.js';
import { __require as requireRetry } from '../retry/index.js';

var hasRequiredPRetry;

function requirePRetry () {
	if (hasRequiredPRetry) return pRetry.exports;
	hasRequiredPRetry = 1;
	const retry = /*@__PURE__*/ requireRetry();

	const networkErrorMsgs = [
		'Failed to fetch', // Chrome
		'NetworkError when attempting to fetch resource.', // Firefox
		'The Internet connection appears to be offline.', // Safari
		'Network request failed' // `cross-fetch`
	];

	class AbortError extends Error {
		constructor(message) {
			super();

			if (message instanceof Error) {
				this.originalError = message;
				({message} = message);
			} else {
				this.originalError = new Error(message);
				this.originalError.stack = this.stack;
			}

			this.name = 'AbortError';
			this.message = message;
		}
	}

	const decorateErrorWithCounts = (error, attemptNumber, options) => {
		// Minus 1 from attemptNumber because the first attempt does not count as a retry
		const retriesLeft = options.retries - (attemptNumber - 1);

		error.attemptNumber = attemptNumber;
		error.retriesLeft = retriesLeft;
		return error;
	};

	const isNetworkError = errorMessage => networkErrorMsgs.includes(errorMessage);

	const pRetry$1 = (input, options) => new Promise((resolve, reject) => {
		options = {
			onFailedAttempt: () => {},
			retries: 10,
			...options
		};

		const operation = retry.operation(options);

		operation.attempt(async attemptNumber => {
			try {
				resolve(await input(attemptNumber));
			} catch (error) {
				if (!(error instanceof Error)) {
					reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
					return;
				}

				if (error instanceof AbortError) {
					operation.stop();
					reject(error.originalError);
				} else if (error instanceof TypeError && !isNetworkError(error.message)) {
					operation.stop();
					reject(error);
				} else {
					decorateErrorWithCounts(error, attemptNumber, options);

					try {
						await options.onFailedAttempt(error);
					} catch (error) {
						reject(error);
						return;
					}

					if (!operation.retry(error)) {
						reject(operation.mainError());
					}
				}
			}
		});
	});

	pRetry.exports = pRetry$1;
	// TODO: remove this in the next major version
	pRetry.exports.default = pRetry$1;

	pRetry.exports.AbortError = AbortError;
	return pRetry.exports;
}

export { requirePRetry as __require };
//# sourceMappingURL=index.js.map