@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/cjs/loader.js

@@ -44,6 +44,8 @@ const utils_namespaceObject = require("@modern-js/utils");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const effectClientGenerator_js_namespaceObject = require("./utils/effectClientGenerator.js");
+const EFFECT_BFF_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
+const EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY = 'modern-bff-runtime-source';
 async function transformEffectRuntimeSource(source, filename) {
     const swc = await import("@swc/core");
     const result = await swc.transform(source, {
@@ -62,22 +64,36 @@ async function transformEffectRuntimeSource(source, filename) {
     });
     return result.code;
 }
+function createEffectWorkerRuntimeWrapper(resourcePath) {
+    const sourceRequest = `${resourcePath}?${EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY}`;
+    return `import * as effectBffModule from ${JSON.stringify(sourceRequest)};
+import { createEffectBffEdgeDispatcher } from '@modern-js/plugin-bff/effect-edge';
+
+export const __modern_create_effect_bff_dispatcher = options =>
+  createEffectBffEdgeDispatcher({
+    ...options,
+    module: effectBffModule,
+  });
+`;
+}
 async function loader(source) {
     this.cacheable();
     const { resourcePath } = this;
     delete require.cache[resourcePath];
     const callback = this.async();
     const draftOptions = this.getOptions();
+    const resourceQueries = new URLSearchParams(this.resourceQuery);
     const effectEntryFile = (0, effectClientGenerator_js_namespaceObject.resolveEffectEntryFile)({
         appDir: draftOptions.appDir,
         apiDir: draftOptions.apiDir,
         effectEntry: draftOptions.effectEntry
     });
-    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath) && this.resourceQuery.includes('modern-bff-runtime')) {
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_SOURCE_QUERY)) {
         const code = await transformEffectRuntimeSource(source, resourcePath);
         callback(void 0, code);
         return;
     }
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath) && resourceQueries.has(EFFECT_BFF_WORKER_RUNTIME_QUERY)) return void callback(void 0, createEffectWorkerRuntimeWrapper(resourcePath));
     if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath)) {
         const code = await (0, effectClientGenerator_js_namespaceObject.generateEffectClientCode)({
             appDir: draftOptions.appDir,
@@ -88,7 +104,8 @@ async function loader(source) {
             target: draftOptions.target,
             requestCreator: draftOptions.requestCreator,
             httpMethodDecider: draftOptions.httpMethodDecider,
-            dataPlatformBatch: draftOptions.effectDataPlatformBatch
+            dataPlatformBatch: draftOptions.effectDataPlatformBatch,
+            onDependency: (dependency)=>this.addDependency(dependency)
         });
         if (code) return void callback(void 0, code);
         callback(void 0, `throw new Error('Failed to generate Effect client for ${resourcePath}')`);

package/dist/cjs/runtime/data-platform/batch/queue.js

@@ -0,0 +1,284 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createBatchTransportQueue: ()=>createBatchTransportQueue
+});
+const external_codec_js_namespaceObject = require("../codec.js");
+const external_types_js_namespaceObject = require("../types.js");
+const external_request_js_namespaceObject = require("./request.js");
+const external_response_js_namespaceObject = require("./response.js");
+const external_telemetry_js_namespaceObject = require("./telemetry.js");
+const external_url_js_namespaceObject = require("./url.js");
+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 (0, external_response_js_namespaceObject.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)) {
+            (0, external_telemetry_js_namespaceObject.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 = (0, external_request_js_namespaceObject.createBatchId)();
+        const payload = {
+            protocolVersion: 1,
+            batchId,
+            sentAt: Date.now(),
+            items: items.map((item)=>item.item)
+        };
+        (0, external_telemetry_js_namespaceObject.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',
+                [external_types_js_namespaceObject.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();
+                    (0, external_telemetry_js_namespaceObject.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);
+                    (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                        type: 'disable',
+                        endpoint,
+                        batchId,
+                        reason: `batch-endpoint-unavailable-${String(response.status)}`
+                    });
+                } else (0, external_telemetry_js_namespaceObject.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 (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) {
+                (0, external_telemetry_js_namespaceObject.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 (0, external_response_js_namespaceObject.parseResponseLikeCreateRequest)(reconstructedResponse);
+            });
+        } catch (error) {
+            (0, external_telemetry_js_namespaceObject.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 = (0, external_url_js_namespaceObject.toAbsoluteUrl)(input);
+        const batchEndpointUrl = (0, external_url_js_namespaceObject.normalizeBatchEndpoint)(requestUrl, options.endpoint);
+        const endpoint = batchEndpointUrl.toString();
+        const method = (0, external_request_js_namespaceObject.normalizeMethod)(init?.method);
+        const body = (0, external_request_js_namespaceObject.toRequestBody)(init?.body ?? null);
+        const headers = (0, external_request_js_namespaceObject.toHeaderRecord)(init?.headers);
+        const normalizedInit = {
+            ...init,
+            method,
+            headers,
+            body
+        };
+        if (disabledEndpoints.has(endpoint) || !(0, external_request_js_namespaceObject.shouldBatchRequest)({
+            method,
+            body,
+            headers,
+            allowedMethods,
+            batchEndpoint: endpoint,
+            requestUrl
+        })) return baseFetch(requestUrl.toString(), normalizedInit).then(external_response_js_namespaceObject.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 = (0, external_codec_js_namespaceObject.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 = (0, external_request_js_namespaceObject.measureTextBytes)((0, external_codec_js_namespaceObject.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;
+            (0, external_telemetry_js_namespaceObject.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;
+    };
+}
+exports.createBatchTransportQueue = __webpack_exports__.createBatchTransportQueue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBatchTransportQueue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/batch/request.js

@@ -0,0 +1,98 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createBatchId: ()=>createBatchId,
+    measureTextBytes: ()=>measureTextBytes,
+    normalizeMethod: ()=>normalizeMethod,
+    shouldBatchRequest: ()=>shouldBatchRequest,
+    toHeaderRecord: ()=>toHeaderRecord,
+    toRequestBody: ()=>toRequestBody
+});
+const external_types_js_namespaceObject = require("../types.js");
+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[external_types_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER]) return false;
+    if (!input.allowedMethods.has(input.method)) return false;
+    if (void 0 !== input.body) return false;
+    return true;
+}
+exports.createBatchId = __webpack_exports__.createBatchId;
+exports.measureTextBytes = __webpack_exports__.measureTextBytes;
+exports.normalizeMethod = __webpack_exports__.normalizeMethod;
+exports.shouldBatchRequest = __webpack_exports__.shouldBatchRequest;
+exports.toHeaderRecord = __webpack_exports__.toHeaderRecord;
+exports.toRequestBody = __webpack_exports__.toRequestBody;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBatchId",
+    "measureTextBytes",
+    "normalizeMethod",
+    "shouldBatchRequest",
+    "toHeaderRecord",
+    "toRequestBody"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/batch/response.js

@@ -0,0 +1,64 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    isBatchResponsePayload: ()=>isBatchResponsePayload,
+    parseResponseLikeCreateRequest: ()=>parseResponseLikeCreateRequest
+});
+const external_codec_js_namespaceObject = require("../codec.js");
+function isBatchResponseItem(value) {
+    return (0, external_codec_js_namespaceObject.isPlainObject)(value) && 'string' == typeof value.id && 'number' == typeof value.status;
+}
+function isBatchResponsePayload(value) {
+    return (0, external_codec_js_namespaceObject.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();
+}
+exports.isBatchResponsePayload = __webpack_exports__.isBatchResponsePayload;
+exports.parseResponseLikeCreateRequest = __webpack_exports__.parseResponseLikeCreateRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isBatchResponsePayload",
+    "parseResponseLikeCreateRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/batch/telemetry.js

@@ -0,0 +1,67 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>DATA_BATCH_TRANSPORT_OTEL_EVENT,
+    createDataBatchTransportTelemetryAttributes: ()=>createDataBatchTransportTelemetryAttributes,
+    emitDataBatchTransportEvent: ()=>emitDataBatchTransportEvent
+});
+const api_namespaceObject = require("@opentelemetry/api");
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    onEvent?.(event);
+    api_namespaceObject.trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+}
+exports.DATA_BATCH_TRANSPORT_OTEL_EVENT = __webpack_exports__.DATA_BATCH_TRANSPORT_OTEL_EVENT;
+exports.createDataBatchTransportTelemetryAttributes = __webpack_exports__.createDataBatchTransportTelemetryAttributes;
+exports.emitDataBatchTransportEvent = __webpack_exports__.emitDataBatchTransportEvent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DATA_BATCH_TRANSPORT_OTEL_EVENT",
+    "createDataBatchTransportTelemetryAttributes",
+    "emitDataBatchTransportEvent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/data-platform/batch/url.js

@@ -0,0 +1,69 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    normalizeBatchEndpoint: ()=>normalizeBatchEndpoint,
+    resolveRuntimeOrigin: ()=>resolveRuntimeOrigin,
+    toAbsoluteUrl: ()=>toAbsoluteUrl
+});
+const external_types_js_namespaceObject = require("../types.js");
+function resolveRuntimeOrigin() {
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    if ("u" > typeof globalThis && globalThis.location && 'string' == typeof globalThis.location?.origin) return globalThis.location.origin;
+    return 'http://localhost';
+}
+function toAbsoluteUrl(input) {
+    if (input instanceof URL) return input;
+    if ("u" > typeof Request && input instanceof Request) return new URL(input.url);
+    const value = String(input);
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, resolveRuntimeOrigin());
+    }
+}
+function normalizeBatchEndpoint(requestUrl, endpoint) {
+    const value = endpoint || external_types_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT;
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, requestUrl.origin);
+    }
+}
+exports.normalizeBatchEndpoint = __webpack_exports__.normalizeBatchEndpoint;
+exports.resolveRuntimeOrigin = __webpack_exports__.resolveRuntimeOrigin;
+exports.toAbsoluteUrl = __webpack_exports__.toAbsoluteUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeBatchEndpoint",
+    "resolveRuntimeOrigin",
+    "toAbsoluteUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});