@bleedingdev/modern-js-plugin-bff 3.8.3-ultramodern.1 → 3.8.3-ultramodern.3

package/dist/cjs/utils/effectSourceLoader.js

@@ -1,312 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    bundleEffectEntryForNode: ()=>bundleEffectEntryForNode,
-    loadEffectBuiltModule: ()=>loadEffectBuiltModule,
-    loadEffectSourceModule: ()=>loadEffectSourceModule
-});
-const external_node_crypto_namespaceObject = require("node:crypto");
-var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-const external_node_module_namespaceObject = require("node:module");
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const external_node_url_namespaceObject = require("node:url");
-const external_esbuild_namespaceObject = require("esbuild");
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-const SOURCE_LOADERS = new Map([
-    [
-        '.js',
-        'js'
-    ],
-    [
-        '.jsx',
-        'jsx'
-    ],
-    [
-        '.mjs',
-        'js'
-    ],
-    [
-        '.cjs',
-        'js'
-    ],
-    [
-        '.ts',
-        'ts'
-    ],
-    [
-        '.tsx',
-        'tsx'
-    ],
-    [
-        '.mts',
-        'ts'
-    ],
-    [
-        '.cts',
-        'ts'
-    ]
-]);
-function sourceLoader(args) {
-    return SOURCE_LOADERS.get(external_node_path_default().extname(args.path).toLowerCase());
-}
-function preserveSourceModuleSemantics() {
-    return {
-        name: 'modern-js-effect-source-semantics',
-        setup (buildApi) {
-            buildApi.onLoad({
-                filter: /\.[cm]?[jt]sx?$/
-            }, async (args)=>{
-                const loader = sourceLoader(args);
-                if (!loader) return;
-                const source = await external_node_fs_default().promises.readFile(args.path, 'utf8');
-                const compiled = await (0, external_esbuild_namespaceObject.transform)(source, {
-                    define: {
-                        'import.meta.url': JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(args.path).href)
-                    },
-                    jsx: 'automatic',
-                    loader,
-                    sourcefile: args.path,
-                    target: 'node20'
-                });
-                return {
-                    contents: compiled.code,
-                    loader: 'js',
-                    resolveDir: external_node_path_default().dirname(args.path)
-                };
-            });
-        }
-    };
-}
-const nodeBuiltins = new Set([
-    ...external_node_module_namespaceObject.builtinModules,
-    ...external_node_module_namespaceObject.builtinModules.map((name)=>`node:${name}`)
-]);
-const dependencyResolutionMarker = 'modern-js-effect-dependency-resolution';
-async function isEsmOnlyFile(filename) {
-    const extension = external_node_path_default().extname(filename).toLowerCase();
-    if ('.mjs' === extension || '.mts' === extension) return true;
-    if ('.cjs' === extension || '.cts' === extension) return false;
-    let directory = external_node_path_default().dirname(filename);
-    while(true){
-        const packagePath = external_node_path_default().join(directory, 'package.json');
-        try {
-            const packageJson = JSON.parse(await external_node_fs_default().promises.readFile(packagePath, 'utf8'));
-            return 'module' === packageJson.type;
-        } catch (error) {
-            if (!error || 'object' != typeof error || !('code' in error) || 'ENOENT' !== error.code) throw error;
-        }
-        const parent = external_node_path_default().dirname(directory);
-        if (parent === directory) return false;
-        directory = parent;
-    }
-}
-function isBareSpecifier(specifier) {
-    return !specifier.startsWith('.') && !specifier.startsWith('/') && !external_node_path_default().isAbsolute(specifier);
-}
-function externalizeInstalledDependencies(options) {
-    const runtimeRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(options.runtimeResolveDir, '__modern_effect_entry.cjs'));
-    return {
-        name: 'modern-js-effect-installed-dependencies',
-        setup (buildApi) {
-            buildApi.onResolve({
-                filter: /.*/
-            }, async (args)=>{
-                if (!isBareSpecifier(args.path) || nodeBuiltins.has(args.path) || args.pluginData?.[dependencyResolutionMarker] === true) return nodeBuiltins.has(args.path) ? {
-                    external: true,
-                    path: args.path
-                } : void 0;
-                const resolution = await buildApi.resolve(args.path, {
-                    importer: args.importer,
-                    kind: args.kind,
-                    namespace: args.namespace,
-                    pluginData: {
-                        ...args.pluginData,
-                        [dependencyResolutionMarker]: true
-                    },
-                    resolveDir: args.resolveDir
-                });
-                if (resolution.errors.length > 0) return {
-                    external: true,
-                    path: args.path
-                };
-                if (resolution.external || !resolution.path) return {
-                    external: true,
-                    path: args.path
-                };
-                const realPath = await external_node_fs_default().promises.realpath(resolution.path).catch(()=>resolution.path);
-                if (realPath.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`)) {
-                    const runtimeResolution = await buildApi.resolve(args.path, {
-                        importer: '',
-                        kind: args.kind,
-                        namespace: 'file',
-                        pluginData: {
-                            [dependencyResolutionMarker]: true
-                        },
-                        resolveDir: options.runtimeResolveDir
-                    });
-                    if (0 === runtimeResolution.errors.length && runtimeResolution.path) {
-                        if ('cjs' === options.format) {
-                            let requiredPath;
-                            try {
-                                requiredPath = runtimeRequire.resolve(args.path);
-                            } catch  {
-                                requiredPath = runtimeResolution.path;
-                            }
-                            if (await isEsmOnlyFile(requiredPath)) return {
-                                namespace: resolution.namespace,
-                                path: resolution.path,
-                                pluginData: resolution.pluginData,
-                                sideEffects: resolution.sideEffects,
-                                suffix: resolution.suffix,
-                                warnings: resolution.warnings
-                            };
-                        }
-                        return {
-                            external: true,
-                            path: args.path
-                        };
-                    }
-                }
-                return {
-                    namespace: resolution.namespace,
-                    path: resolution.path,
-                    pluginData: resolution.pluginData,
-                    sideEffects: resolution.sideEffects,
-                    suffix: resolution.suffix,
-                    warnings: resolution.warnings
-                };
-            });
-        }
-    };
-}
-async function bundleEffectEntryForNode(options) {
-    await (0, external_esbuild_namespaceObject.build)({
-        absWorkingDir: options.appDir,
-        allowOverwrite: true,
-        bundle: true,
-        entryPoints: [
-            options.entryPath
-        ],
-        format: options.format,
-        logLevel: 'silent',
-        outfile: options.entryPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: options.format,
-                runtimeResolveDir: options.appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        target: 'node20'
-    });
-}
-function isWatchableInput(filename) {
-    return !filename.includes(`${external_node_path_default().sep}node_modules${external_node_path_default().sep}`) && (SOURCE_LOADERS.has(external_node_path_default().extname(filename).toLowerCase()) || '.json' === external_node_path_default().extname(filename).toLowerCase());
-}
-function normalizeImportedModule(module) {
-    if (!module || 'object' != typeof module) return module;
-    const namespace = module;
-    const commonJsModule = namespace.default;
-    if (1 === Object.keys(namespace).length && null !== commonJsModule && 'object' == typeof commonJsModule && true === commonJsModule.__esModule) return commonJsModule;
-    return module;
-}
-async function loadEffectBuiltModule(resourcePath) {
-    const canonicalPath = await external_node_fs_default().promises.realpath(external_node_path_default().resolve(resourcePath));
-    if (!await isEsmOnlyFile(canonicalPath)) return (0, external_node_module_namespaceObject.createRequire)(canonicalPath)(canonicalPath);
-    return normalizeImportedModule(await dynamicImport((0, external_node_url_namespaceObject.pathToFileURL)(canonicalPath).href));
-}
-async function loadEffectSourceModule(options) {
-    const resourcePath = external_node_path_default().resolve(options.resourcePath);
-    const appDir = external_node_path_default().resolve(options.appDir ?? external_node_path_default().dirname(resourcePath));
-    const tsconfigPath = external_node_path_default().join(appDir, 'tsconfig.json');
-    const cacheDirectory = external_node_path_default().join(appDir, 'node_modules', '.cache', 'modern-js', 'effect-source-loader');
-    const outputName = external_node_crypto_default().createHash('sha256').update(resourcePath).digest('hex').slice(0, 24);
-    const outputPath = external_node_path_default().join(cacheDirectory, `${outputName}.mjs`);
-    await external_node_fs_default().promises.mkdir(cacheDirectory, {
-        recursive: true
-    });
-    const result = await (0, external_esbuild_namespaceObject.build)({
-        absWorkingDir: appDir,
-        banner: {
-            js: `import { createRequire as __modernCreateEffectRequire } from 'node:module'; const require = __modernCreateEffectRequire(${JSON.stringify((0, external_node_url_namespaceObject.pathToFileURL)(resourcePath).href)});`
-        },
-        bundle: true,
-        entryPoints: [
-            resourcePath
-        ],
-        format: 'esm',
-        jsx: 'automatic',
-        logLevel: 'silent',
-        metafile: true,
-        outfile: outputPath,
-        platform: 'node',
-        plugins: [
-            externalizeInstalledDependencies({
-                format: 'esm',
-                runtimeResolveDir: appDir
-            }),
-            preserveSourceModuleSemantics()
-        ],
-        sourcemap: 'inline',
-        target: 'node20',
-        tsconfig: external_node_fs_default().existsSync(tsconfigPath) ? tsconfigPath : void 0
-    });
-    for (const input of Object.keys(result.metafile.inputs)){
-        const dependency = external_node_path_default().isAbsolute(input) ? external_node_path_default().normalize(input) : external_node_path_default().resolve(appDir, input);
-        if (isWatchableInput(dependency)) options.onDependency?.(dependency);
-    }
-    const output = await external_node_fs_default().promises.readFile(outputPath);
-    const revision = external_node_crypto_default().createHash('sha256').update(output).digest('hex');
-    return normalizeImportedModule(await dynamicImport(`${(0, external_node_url_namespaceObject.pathToFileURL)(outputPath).href}?v=${revision}`));
-}
-exports.bundleEffectEntryForNode = __webpack_exports__.bundleEffectEntryForNode;
-exports.loadEffectBuiltModule = __webpack_exports__.loadEffectBuiltModule;
-exports.loadEffectSourceModule = __webpack_exports__.loadEffectSourceModule;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "bundleEffectEntryForNode",
-    "loadEffectBuiltModule",
-    "loadEffectSourceModule"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/utils/headers.js

@@ -1,46 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-function toHeaderRecord(headers) {
-    const record = {};
-    headers.forEach((value, key)=>{
-        record[key] = value;
-    });
-    return record;
-}
-__webpack_require__.d(__webpack_exports__, {
-    toHeaderRecord: ()=>toHeaderRecord
-});
-exports.toHeaderRecord = __webpack_exports__.toHeaderRecord;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "toHeaderRecord"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

@@ -1,246 +0,0 @@
-import { stableStringify } from "../codec.mjs";
-import { DEFAULT_DATA_BATCH_HEADER } from "../types.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";
-function ensureBucket(buckets, endpoint) {
-    const existing = buckets.get(endpoint);
-    if (existing) return existing;
-    const next = {
-        items: [],
-        bytes: 0,
-        timer: null,
-        flushing: false
-    };
-    buckets.set(endpoint, next);
-    return next;
-}
-function createBatchTransportQueue({ options, baseFetch }) {
-    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 = new Map();
-    const pendingByKey = new Map();
-    const disabledEndpoints = new Set();
-    let nextItemId = 0;
-    const runSingle = async (request)=>{
-        const response = await baseFetch(request.requestUrl, request.requestInit);
-        return parseResponseLikeCreateRequest(response);
-    };
-    const settleRequests = async (items, runner)=>{
-        await Promise.all(items.map(async (item)=>{
-            try {
-                const value = await runner(item);
-                item.resolve(value);
-            } catch (error) {
-                item.reject(error);
-            } finally{
-                pendingByKey.delete(item.key);
-            }
-        }));
-    };
-    const flushBucket = async (endpoint)=>{
-        const bucket = buckets.get(endpoint);
-        if (!bucket || bucket.flushing) return;
-        if (bucket.timer) {
-            clearTimeout(bucket.timer);
-            bucket.timer = null;
-        }
-        if (0 === bucket.items.length) return;
-        bucket.flushing = true;
-        const items = bucket.items;
-        bucket.items = [];
-        bucket.bytes = 0;
-        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(endpoint);
-            return;
-        }
-        const batchId = createBatchId();
-        const payload = {
-            protocolVersion: 1,
-            batchId,
-            sentAt: Date.now(),
-            items: items.map((item)=>item.item)
-        };
-        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 requestInit = {
-            method: 'POST',
-            headers: {
-                accept: 'application/json, */*;q=0.8',
-                'content-type': 'application/json; charset=utf-8',
-                [DEFAULT_DATA_BATCH_HEADER]: '1',
-                ...traceparent ? {
-                    traceparent
-                } : {}
-            },
-            body: payloadJson
-        };
-        let timeoutHandle = null;
-        try {
-            const controller = requestTimeoutMs && requestTimeoutMs > 0 ? new AbortController() : void 0;
-            if (controller) {
-                requestInit.signal = controller.signal;
-                timeoutHandle = setTimeout(()=>{
-                    controller.abort();
-                    emitDataBatchTransportEvent(onEvent, {
-                        type: 'fallback',
-                        endpoint,
-                        batchId,
-                        size: items.length,
-                        reason: 'batch-timeout'
-                    });
-                }, requestTimeoutMs);
-            }
-            const response = await 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 settleRequests(items, runSingle);
-                bucket.flushing = false;
-                return;
-            }
-            const result = await response.json();
-            if (!isBatchResponsePayload(result)) {
-                emitDataBatchTransportEvent(onEvent, {
-                    type: 'fallback',
-                    endpoint,
-                    batchId,
-                    size: items.length,
-                    reason: 'invalid-batch-response'
-                });
-                await settleRequests(items, runSingle);
-                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 runSingle(request);
-                const reconstructedResponse = new Response(resultItem.body ?? '', {
-                    status: resultItem.status,
-                    headers: resultItem.headers
-                });
-                return parseResponseLikeCreateRequest(reconstructedResponse);
-            });
-        } catch (error) {
-            emitDataBatchTransportEvent(onEvent, {
-                type: 'fallback',
-                endpoint,
-                batchId,
-                size: items.length,
-                reason: 'batch-transport-error'
-            });
-            await settleRequests(items, runSingle);
-        } finally{
-            if (timeoutHandle) clearTimeout(timeoutHandle);
-            bucket.flushing = false;
-            if (bucket.items.length > 0 && !bucket.timer) flushBucket(endpoint);
-        }
-    };
-    return (input, init)=>{
-        const requestUrl = toAbsoluteUrl(input);
-        const batchEndpointUrl = normalizeBatchEndpoint(requestUrl, options.endpoint);
-        const endpoint = batchEndpointUrl.toString();
-        const method = normalizeMethod(init?.method);
-        const body = toRequestBody(init?.body ?? null);
-        const headers = toHeaderRecord(init?.headers);
-        const normalizedInit = {
-            ...init,
-            method,
-            headers,
-            body
-        };
-        if (disabledEndpoints.has(endpoint) || !shouldBatchRequest({
-            method,
-            body,
-            headers,
-            allowedMethods,
-            batchEndpoint: endpoint,
-            requestUrl
-        })) return baseFetch(requestUrl.toString(), normalizedInit).then(parseResponseLikeCreateRequest);
-        const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
-        nextItemId += 1;
-        const item = {
-            id: itemId,
-            path: `${requestUrl.pathname}${requestUrl.search}`,
-            method,
-            headers,
-            ...body ? {
-                body
-            } : {}
-        };
-        const key = stableStringify({
-            endpoint,
-            path: item.path,
-            method: item.method,
-            headers: item.headers,
-            body: item.body ?? null
-        });
-        const existing = pendingByKey.get(key);
-        if (existing) return existing;
-        const size = measureTextBytes(stableStringify(item));
-        const promise = new Promise((resolve, reject)=>{
-            const bucket = ensureBucket(buckets, endpoint);
-            const queued = {
-                key,
-                endpoint,
-                requestUrl: requestUrl.toString(),
-                requestInit: normalizedInit,
-                item,
-                size,
-                resolve,
-                reject
-            };
-            bucket.items.push(queued);
-            bucket.bytes += size;
-            emitDataBatchTransportEvent(onEvent, {
-                type: 'enqueue',
-                endpoint,
-                size: bucket.items.length
-            });
-            if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) return void flushBucket(endpoint);
-            if (!bucket.timer) bucket.timer = setTimeout(()=>{
-                bucket.timer = null;
-                flushBucket(endpoint);
-            }, flushIntervalMs);
-        });
-        pendingByKey.set(key, promise);
-        return promise;
-    };
-}
-export { createBatchTransportQueue };

package/dist/esm/runtime/data-platform/batch/request.mjs

@@ -1,45 +0,0 @@
-import { DEFAULT_DATA_BATCH_HEADER } from "../types.mjs";
-function toHeaderRecord(headers) {
-    if (!headers) return {};
-    if (headers instanceof Headers) {
-        const next = {};
-        headers.forEach((value, key)=>{
-            next[key.toLowerCase()] = value;
-        });
-        return next;
-    }
-    if (Array.isArray(headers)) return headers.reduce((acc, [key, value])=>{
-        acc[String(key).toLowerCase()] = String(value);
-        return acc;
-    }, {});
-    return Object.entries(headers).reduce((acc, [key, value])=>{
-        if (void 0 === value) return acc;
-        acc[String(key).toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value);
-        return acc;
-    }, {});
-}
-function measureTextBytes(value) {
-    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
-    if ("u" > typeof Buffer) return Buffer.byteLength(value);
-    return value.length;
-}
-function createBatchId() {
-    const now = Date.now().toString(36);
-    const random = Math.random().toString(16).slice(2, 10);
-    return `batch_${now}_${random}`;
-}
-function normalizeMethod(method) {
-    return (method || 'GET').toUpperCase();
-}
-function toRequestBody(initBody) {
-    if ('string' == typeof initBody) return initBody;
-    if ("u" > typeof URLSearchParams && initBody instanceof URLSearchParams) return initBody.toString();
-}
-function shouldBatchRequest(input) {
-    if (input.requestUrl.href === input.batchEndpoint) return false;
-    if ('off' === input.headers[DEFAULT_DATA_BATCH_HEADER]) return false;
-    if (!input.allowedMethods.has(input.method)) return false;
-    if (void 0 !== input.body) return false;
-    return true;
-}
-export { createBatchId, measureTextBytes, normalizeMethod, shouldBatchRequest, toHeaderRecord, toRequestBody };

package/dist/esm/runtime/data-platform/batch/response.mjs

@@ -1,23 +0,0 @@
-import { isPlainObject } from "../codec.mjs";
-function isBatchResponseItem(value) {
-    return isPlainObject(value) && 'string' == typeof value.id && 'number' == typeof value.status;
-}
-function isBatchResponsePayload(value) {
-    return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.receivedAt && Array.isArray(value.items) && value.items.every((item)=>isBatchResponseItem(item));
-}
-async function parseResponseLikeCreateRequest(response) {
-    const contentType = (response.headers.get('content-type') || '').toLowerCase();
-    if (!response.ok) {
-        let data = null;
-        data = contentType.includes('application/json') ? await response.json() : await response.text();
-        response.data = data;
-        throw response;
-    }
-    if (contentType.includes('application/json') || contentType.includes('text/json')) return response.json();
-    if (contentType.includes('text/html') || contentType.includes('text/plain')) return response.text();
-    if (contentType.includes('application/x-www-form-urlencoded') || contentType.includes('multipart/form-data')) return response.formData();
-    if (contentType.includes('application/octet-stream')) return response.arrayBuffer();
-    if (contentType.includes('image/png')) return response;
-    return response.text();
-}
-export { isBatchResponsePayload, parseResponseLikeCreateRequest };