@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/esm-node/data-platform/batch/protocol.mjs

@@ -0,0 +1,72 @@
+import "node:module";
+import { isPlainObject } from "../codec.mjs";
+const BASE64_CHUNK_SIZE = 0x8000;
+const CANONICAL_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const RESPONSE_BLOCKED_HEADERS = new Set([
+    'connection',
+    'content-length',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'proxy-connection',
+    'set-cookie',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade'
+]);
+const NULL_BODY_STATUSES = new Set([
+    204,
+    205,
+    304
+]);
+function encodeBatchBody(bytes) {
+    let binary = '';
+    for(let offset = 0; offset < bytes.byteLength; offset += BASE64_CHUNK_SIZE)binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_SIZE));
+    return {
+        encoding: 'base64',
+        data: btoa(binary)
+    };
+}
+function encodeBatchText(value) {
+    return encodeBatchBody(new TextEncoder().encode(value));
+}
+function decodeBatchBody(body) {
+    const binary = atob(body.data);
+    const bytes = new Uint8Array(binary.length);
+    for(let index = 0; index < binary.length; index += 1)bytes[index] = binary.charCodeAt(index);
+    return bytes;
+}
+function isBatchBody(value) {
+    return isPlainObject(value) && 'base64' === value.encoding && 'string' == typeof value.data && CANONICAL_BASE64.test(value.data) && btoa(atob(value.data)) === value.data;
+}
+function isBatchHeaderList(value) {
+    return Array.isArray(value) && value.every((entry)=>Array.isArray(entry) && 2 === entry.length && 'string' == typeof entry[0] && 'string' == typeof entry[1]);
+}
+function isNullBodyStatus(status) {
+    return NULL_BODY_STATUSES.has(status);
+}
+function toBatchResponseHeaders(headers) {
+    const connectionHeaders = new Set((headers.get('connection') || '').split(',').map((header)=>header.trim().toLowerCase()).filter(Boolean));
+    const output = [];
+    headers.forEach((value, name)=>{
+        const normalizedName = name.toLowerCase();
+        if (!RESPONSE_BLOCKED_HEADERS.has(normalizedName) && !connectionHeaders.has(normalizedName)) output.push([
+            normalizedName,
+            value
+        ]);
+    });
+    return output;
+}
+async function toBatchResponseItem(id, response, omitBody = false) {
+    const body = omitBody || null === response.body ? void 0 : encodeBatchBody(new Uint8Array(await response.arrayBuffer()));
+    return {
+        id,
+        status: response.status,
+        headers: toBatchResponseHeaders(response.headers),
+        ...body ? {
+            body
+        } : {}
+    };
+}
+export { decodeBatchBody, encodeBatchBody, encodeBatchText, isBatchBody, isBatchHeaderList, isNullBodyStatus, toBatchResponseHeaders, toBatchResponseItem };

package/dist/esm-node/data-platform/batch/queue.mjs

@@ -0,0 +1,583 @@
+import "node:module";
+import { stableStringify } from "../codec.mjs";
+import { DEFAULT_DATA_BATCH_HEADER } from "../types.mjs";
+import { decodeBatchBody, isNullBodyStatus } from "./protocol.mjs";
+import { createBatchId, measureTextBytes, normalizeMethod, shouldBatchRequest, toHeaderRecord, toRequestBody } from "./request.mjs";
+import { isBatchResponsePayload, parseResponseLikeCreateRequest } from "./response.mjs";
+import { emitDataBatchTransportEvent } from "./telemetry.mjs";
+import { normalizeBatchEndpoint, toAbsoluteUrl } from "./url.mjs";
+const SAFE_REPLAY_METHODS = new Set([
+    'GET',
+    'HEAD'
+]);
+const abortReason = (signal)=>signal.reason ?? new DOMException('The request was aborted', 'AbortError');
+const createRequestLifetime = (sourceSignal, timeoutMs)=>{
+    const controller = new AbortController();
+    let timedOut = false;
+    let timeoutHandle = null;
+    const abortFromSource = ()=>{
+        if (sourceSignal) controller.abort(abortReason(sourceSignal));
+    };
+    if (sourceSignal?.aborted) abortFromSource();
+    else if (sourceSignal) sourceSignal.addEventListener('abort', abortFromSource, {
+        once: true
+    });
+    if (!controller.signal.aborted && timeoutMs && timeoutMs > 0) timeoutHandle = setTimeout(()=>{
+        timedOut = true;
+        controller.abort(new DOMException('The batched request timed out', 'TimeoutError'));
+    }, timeoutMs);
+    return {
+        signal: controller.signal,
+        get timedOut () {
+            return timedOut;
+        },
+        dispose () {
+            if (null !== timeoutHandle) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+            }
+            sourceSignal?.removeEventListener('abort', abortFromSource);
+        }
+    };
+};
+const runWithSignal = (signal, operation)=>{
+    if (signal.aborted) return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(abortReason(signal));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        let pending;
+        try {
+            pending = operation();
+        } catch (error) {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+            return;
+        }
+        pending.then((value)=>{
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error)=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+};
+class BatchBucketRegistry {
+    get size() {
+        return this.buckets.size;
+    }
+    get(bucketKey) {
+        return this.buckets.get(bucketKey);
+    }
+    ensure(bucketKey) {
+        const existing = this.buckets.get(bucketKey);
+        if (existing) return existing;
+        const next = {
+            items: [],
+            bytes: 0,
+            batchId: createBatchId(),
+            sentAt: Date.now(),
+            timer: null,
+            flushing: false
+        };
+        this.buckets.set(bucketKey, next);
+        return next;
+    }
+    releaseIfIdle(bucketKey, bucket) {
+        if (this.buckets.get(bucketKey) !== bucket || bucket.flushing || null !== bucket.timer || bucket.items.length > 0) return false;
+        return this.buckets.delete(bucketKey);
+    }
+    constructor(){
+        this.buckets = new Map();
+    }
+}
+function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
+    const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
+    const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
+    const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 65536);
+    const requestTimeoutMs = options.requestTimeoutMs;
+    const allowedMethods = new Set((options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+        'GET'
+    ]).map((method)=>method.toUpperCase()));
+    const onEvent = options.onEvent;
+    const buckets = bucketRegistry ?? new BatchBucketRegistry();
+    const pendingByKey = new Map();
+    const disabledEndpoints = new Set();
+    let nextItemId = 0;
+    const createPayload = (bucket, items)=>({
+            protocolVersion: 2,
+            batchId: bucket.batchId,
+            sentAt: bucket.sentAt,
+            items: items.map((item)=>item.item)
+        });
+    const measurePayload = (bucket, items)=>measureTextBytes(JSON.stringify(createPayload(bucket, items)));
+    const rotatePayloadIdentity = (bucket)=>{
+        bucket.batchId = createBatchId();
+        bucket.sentAt = Date.now();
+    };
+    const settleRequest = (request, settlement)=>{
+        if ('settled' === request.phase) return false;
+        request.phase = 'settled';
+        request.lifetime.signal.removeEventListener('abort', request.abortListener);
+        request.lifetime.dispose();
+        if (pendingByKey.get(request.key) === request) pendingByKey.delete(request.key);
+        if ('resolve' === settlement.type) request.resolve(settlement.value);
+        else request.reject(settlement.reason);
+        return true;
+    };
+    const removeQueuedRequest = (request)=>{
+        const bucket = buckets.get(request.bucketKey);
+        if (!bucket) return;
+        const index = bucket.items.indexOf(request);
+        if (-1 === index) return;
+        bucket.items.splice(index, 1);
+        bucket.bytes = measurePayload(bucket, bucket.items);
+        if (0 === bucket.items.length && bucket.timer) {
+            clearTimeout(bucket.timer);
+            bucket.timer = null;
+        }
+        buckets.releaseIfIdle(request.bucketKey, bucket);
+    };
+    const abortQueuedRequest = (request)=>{
+        if ('settled' === request.phase) return;
+        if ('queued' === request.phase) removeQueuedRequest(request);
+        const abortBatchIfUnused = request.abortBatchIfUnused;
+        settleRequest(request, {
+            type: 'reject',
+            reason: abortReason(request.lifetime.signal)
+        });
+        abortBatchIfUnused?.();
+    };
+    const runSingle = (request)=>runWithSignal(request.lifetime.signal, async ()=>{
+            const response = await baseFetch(request.requestInput, request.requestInit);
+            return parseResponseLikeCreateRequest(response);
+        });
+    const settleRequests = async (items, runner)=>{
+        await Promise.all(items.map(async (item)=>{
+            if ('settled' === item.phase) return;
+            try {
+                const value = await runner(item);
+                settleRequest(item, {
+                    type: 'resolve',
+                    value
+                });
+            } catch (error) {
+                settleRequest(item, {
+                    type: 'reject',
+                    reason: error
+                });
+            }
+        }));
+    };
+    const runAfterAmbiguousBatch = (request, reason)=>{
+        if (!SAFE_REPLAY_METHODS.has(request.item.method)) throw new Error(`Batch result is unknown for ${request.item.method}; automatic replay is disabled (${reason}).`);
+        return runSingle(request);
+    };
+    const settleAmbiguousBatchRequests = (items, reason)=>settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+    const flushBucket = async (bucketKey)=>{
+        const bucket = buckets.get(bucketKey);
+        if (!bucket || bucket.flushing) return;
+        if (bucket.timer) {
+            clearTimeout(bucket.timer);
+            bucket.timer = null;
+        }
+        if (0 === bucket.items.length) return void buckets.releaseIfIdle(bucketKey, bucket);
+        bucket.flushing = true;
+        const items = bucket.items;
+        for (const item of items)item.phase = 'flushing';
+        const payloadIdentity = {
+            batchId: bucket.batchId,
+            sentAt: bucket.sentAt
+        };
+        bucket.items = [];
+        bucket.bytes = 0;
+        rotatePayloadIdentity(bucket);
+        const firstItem = items[0];
+        if (!firstItem) {
+            bucket.flushing = false;
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return;
+        }
+        const endpoint = firstItem.endpoint;
+        if (1 === items.length || disabledEndpoints.has(endpoint)) {
+            emitDataBatchTransportEvent(onEvent, {
+                type: disabledEndpoints.has(endpoint) ? 'fallback' : 'flush',
+                endpoint,
+                size: items.length,
+                reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
+            });
+            await settleRequests(items, runSingle);
+            bucket.flushing = false;
+            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return;
+        }
+        const payload = createPayload(payloadIdentity, items);
+        const batchId = payload.batchId;
+        emitDataBatchTransportEvent(onEvent, {
+            type: 'flush',
+            endpoint,
+            batchId,
+            size: items.length
+        });
+        const payloadJson = JSON.stringify(payload);
+        const traceparent = items.find((item)=>'string' == typeof item.item.headers?.traceparent)?.item.headers?.traceparent || void 0;
+        const authorization = firstItem.authorization;
+        const cookie = firstItem.cookie;
+        const requestInit = {
+            method: 'POST',
+            credentials: firstItem.credentials,
+            headers: {
+                accept: 'application/json, */*;q=0.8',
+                'content-type': 'application/json; charset=utf-8',
+                [DEFAULT_DATA_BATCH_HEADER]: '2',
+                ...traceparent ? {
+                    traceparent
+                } : {},
+                ...'string' == typeof authorization ? {
+                    authorization
+                } : {},
+                ...'string' == typeof cookie ? {
+                    cookie
+                } : {}
+            },
+            body: payloadJson
+        };
+        const controller = new AbortController();
+        let abortedBecauseUnused = false;
+        const abortBatchIfUnused = ()=>{
+            if (!controller.signal.aborted && items.every((item)=>'settled' === item.phase)) {
+                abortedBecauseUnused = true;
+                controller.abort(items.find((item)=>item.lifetime.timedOut) ? new DOMException('The batch timed out', 'TimeoutError') : new DOMException('Every batched request was aborted', 'AbortError'));
+            }
+        };
+        for (const item of items)item.abortBatchIfUnused = abortBatchIfUnused;
+        requestInit.signal = controller.signal;
+        try {
+            const response = await runWithSignal(controller.signal, ()=>baseFetch(endpoint, requestInit));
+            if (!response.ok) {
+                if (404 === response.status || 405 === response.status) {
+                    disabledEndpoints.add(endpoint);
+                    emitDataBatchTransportEvent(onEvent, {
+                        type: 'disable',
+                        endpoint,
+                        batchId,
+                        reason: `batch-endpoint-unavailable-${String(response.status)}`
+                    });
+                } else emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: `batch-response-${String(response.status)}`
+                });
+                await settleAmbiguousBatchRequests(items, `batch-response-${String(response.status)}`);
+                bucket.flushing = false;
+                return;
+            }
+            const result = await runWithSignal(controller.signal, async ()=>response.json());
+            if (!isBatchResponsePayload(result)) {
+                emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'invalid-batch-response'
+                });
+                await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
+                bucket.flushing = false;
+                return;
+            }
+            if (result.batchId !== batchId) {
+                emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'mismatched-batch-id'
+                });
+                await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
+                bucket.flushing = false;
+                return;
+            }
+            const itemMap = new Map();
+            for (const item of result.items)itemMap.set(item.id, item);
+            await settleRequests(items, async (request)=>{
+                const resultItem = itemMap.get(request.item.id);
+                if (!resultItem) return runAfterAmbiguousBatch(request, 'missing-batch-result');
+                const reconstructedBody = resultItem.body ? decodeBatchBody(resultItem.body) : null;
+                const reconstructedResponse = new Response(isNullBodyStatus(resultItem.status) ? null : reconstructedBody, {
+                    status: resultItem.status,
+                    headers: resultItem.headers
+                });
+                return parseResponseLikeCreateRequest(reconstructedResponse);
+            });
+        } catch  {
+            if (abortedBecauseUnused) {
+                if (items.some((item)=>item.lifetime.timedOut)) emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'batch-timeout'
+                });
+                return;
+            }
+            emitDataBatchTransportEvent(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason: 'batch-transport-error'
+            });
+            await settleAmbiguousBatchRequests(items, 'batch-transport-error');
+        } finally{
+            for (const item of items)item.abortBatchIfUnused = void 0;
+            bucket.flushing = false;
+            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+            buckets.releaseIfIdle(bucketKey, bucket);
+        }
+    };
+    const pendingReadPromises = new Map();
+    const normalizeRequest = (input, init)=>{
+        const sourceRequest = "u" > typeof Request && input instanceof Request ? input : void 0;
+        const initDefinesSignal = void 0 !== init && 'signal' in init;
+        const initDefinesBody = void 0 !== init && 'body' in init;
+        const initSnapshot = init ? {
+            ...init
+        } : void 0;
+        const getInitValue = (key)=>{
+            if (!init) return;
+            return Object.prototype.hasOwnProperty.call(initSnapshot, key) ? initSnapshot?.[key] : init[key];
+        };
+        const method = normalizeMethod(getInitValue('method') ?? sourceRequest?.method);
+        const headers = toHeaderRecord(getInitValue('headers') ?? sourceRequest?.headers);
+        const credentials = getInitValue('credentials') ?? sourceRequest?.credentials ?? 'same-origin';
+        const initBody = getInitValue('body');
+        const body = initBody ?? null;
+        const initSignal = initDefinesSignal ? getInitValue('signal') : void 0;
+        const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
+        const requestUrl = toAbsoluteUrl(input);
+        const endpoint = normalizeBatchEndpoint(requestUrl, options.endpoint).toString();
+        return {
+            requestUrl,
+            endpoint,
+            method,
+            headers,
+            credentials,
+            body,
+            hasOpaqueSourceBody: void 0 === initBody && void 0 !== sourceRequest && null !== sourceRequest.body,
+            requestInput: sourceRequest ?? requestUrl.toString(),
+            requestInit: {
+                ...initSnapshot,
+                method,
+                headers,
+                credentials,
+                ...initDefinesBody ? {
+                    body: initBody
+                } : {},
+                ...initDefinesSignal ? {
+                    signal: initSignal
+                } : {}
+            },
+            sourceSignal
+        };
+    };
+    const getPendingReadKey = (request)=>{
+        if (!SAFE_REPLAY_METHODS.has(request.method) || void 0 !== request.sourceSignal || null !== request.body || request.hasOpaqueSourceBody || disabledEndpoints.has(request.endpoint) || !shouldBatchRequest({
+            method: request.method,
+            body: void 0,
+            headers: request.headers,
+            allowedMethods,
+            batchEndpoint: request.endpoint,
+            requestUrl: request.requestUrl
+        })) return;
+        const itemHeaders = {
+            ...request.headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
+        const bucketKey = stableStringify({
+            endpoint: request.endpoint,
+            authorization: request.headers.authorization ?? null,
+            cookie: request.headers.cookie ?? null,
+            credentials: request.credentials
+        });
+        return stableStringify({
+            bucketKey,
+            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            method: request.method,
+            headers: itemHeaders,
+            body: null
+        });
+    };
+    const enqueue = async (request)=>{
+        const preparedBody = await toRequestBody(request.body);
+        const hasOpaqueBody = !preparedBody.batchable || request.hasOpaqueSourceBody;
+        if (disabledEndpoints.has(request.endpoint) || !shouldBatchRequest({
+            method: request.method,
+            body: hasOpaqueBody ? '[opaque request body]' : void 0,
+            headers: request.headers,
+            allowedMethods,
+            batchEndpoint: request.endpoint,
+            requestUrl: request.requestUrl
+        })) return baseFetch(request.requestInput, request.requestInit).then(parseResponseLikeCreateRequest);
+        const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
+        nextItemId += 1;
+        const itemHeaders = {
+            ...request.headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
+        if (preparedBody.body && preparedBody.inferredContentType && !itemHeaders['content-type']) itemHeaders['content-type'] = preparedBody.inferredContentType;
+        const item = {
+            id: itemId,
+            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            method: request.method,
+            headers: itemHeaders,
+            ...preparedBody.body ? {
+                body: preparedBody.body
+            } : {}
+        };
+        const bucketKey = stableStringify({
+            endpoint: request.endpoint,
+            authorization: request.headers.authorization ?? null,
+            cookie: request.headers.cookie ?? null,
+            credentials: request.credentials
+        });
+        const key = stableStringify({
+            bucketKey,
+            path: item.path,
+            method: item.method,
+            headers: item.headers,
+            body: item.body ?? null
+        });
+        const canSharePending = SAFE_REPLAY_METHODS.has(request.method) && void 0 === request.sourceSignal;
+        const existing = canSharePending ? pendingByKey.get(key) : void 0;
+        if (existing) return existing.promise;
+        const lifetime = createRequestLifetime(request.sourceSignal, requestTimeoutMs);
+        request.requestInit.signal = lifetime.signal;
+        const deferred = Promise.withResolvers();
+        const queued = {
+            key,
+            bucketKey,
+            endpoint: request.endpoint,
+            requestInput: request.requestInput,
+            requestInit: request.requestInit,
+            authorization: request.headers.authorization,
+            cookie: request.headers.cookie,
+            credentials: request.credentials,
+            item,
+            lifetime,
+            phase: 'queued',
+            promise: deferred.promise,
+            abortListener: ()=>abortQueuedRequest(queued),
+            resolve: deferred.resolve,
+            reject: deferred.reject
+        };
+        lifetime.signal.addEventListener('abort', queued.abortListener, {
+            once: true
+        });
+        if (lifetime.signal.aborted) {
+            abortQueuedRequest(queued);
+            return queued.promise;
+        }
+        if (canSharePending) pendingByKey.set(key, queued);
+        const bucket = buckets.ensure(bucketKey);
+        const singletonBytes = measurePayload(bucket, [
+            queued
+        ]);
+        if (singletonBytes > maxBatchBytes) {
+            emitDataBatchTransportEvent(onEvent, {
+                type: 'fallback',
+                endpoint: request.endpoint,
+                size: 1,
+                reason: 'batch-item-too-large'
+            });
+            queued.phase = 'flushing';
+            settleRequests([
+                queued
+            ], runSingle);
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return queued.promise;
+        }
+        const candidateItems = [
+            ...bucket.items,
+            queued
+        ];
+        const candidateBytes = measurePayload(bucket, candidateItems);
+        if (bucket.items.length > 0 && candidateBytes > maxBatchBytes) {
+            if (bucket.flushing) {
+                emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint: request.endpoint,
+                    size: 1,
+                    reason: 'batch-capacity-during-flush'
+                });
+                queued.phase = 'flushing';
+                settleRequests([
+                    queued
+                ], runSingle);
+                return queued.promise;
+            }
+            flushBucket(bucketKey);
+            if (measurePayload(bucket, [
+                queued
+            ]) > maxBatchBytes) {
+                emitDataBatchTransportEvent(onEvent, {
+                    type: 'fallback',
+                    endpoint: request.endpoint,
+                    size: 1,
+                    reason: 'batch-item-too-large'
+                });
+                queued.phase = 'flushing';
+                settleRequests([
+                    queued
+                ], runSingle);
+                return queued.promise;
+            }
+        }
+        bucket.items.push(queued);
+        bucket.bytes = measurePayload(bucket, bucket.items);
+        emitDataBatchTransportEvent(onEvent, {
+            type: 'enqueue',
+            endpoint: request.endpoint,
+            size: bucket.items.length
+        });
+        if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) {
+            flushBucket(bucketKey);
+            return queued.promise;
+        }
+        if (!bucket.timer) bucket.timer = setTimeout(()=>{
+            bucket.timer = null;
+            flushBucket(bucketKey);
+        }, flushIntervalMs);
+        return queued.promise;
+    };
+    return (input, init)=>{
+        let request;
+        try {
+            request = normalizeRequest(input, init);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        const pendingReadKey = getPendingReadKey(request);
+        const existing = pendingReadKey ? pendingReadPromises.get(pendingReadKey) : void 0;
+        if (existing) return existing;
+        const pending = enqueue(request);
+        if (pendingReadKey) {
+            pendingReadPromises.set(pendingReadKey, pending);
+            const clearPendingRead = ()=>{
+                if (pendingReadPromises.get(pendingReadKey) === pending) pendingReadPromises.delete(pendingReadKey);
+            };
+            pending.then(clearPendingRead, clearPendingRead);
+        }
+        return pending;
+    };
+}
+export { BatchBucketRegistry, createBatchTransportQueue };