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

package/dist/cjs/effect-client/index.js

@@ -0,0 +1,208 @@
+"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__, {
+    Effect: ()=>Effect_namespaceObject,
+    EffectRpcClientError: ()=>EffectRpcClientError,
+    HttpApi: ()=>httpapi_namespaceObject.HttpApi,
+    HttpApiClient: ()=>httpapi_namespaceObject.HttpApiClient,
+    HttpApiEndpoint: ()=>httpapi_namespaceObject.HttpApiEndpoint,
+    HttpApiGroup: ()=>httpapi_namespaceObject.HttpApiGroup,
+    HttpApiSchema: ()=>httpapi_namespaceObject.HttpApiSchema,
+    HttpClientError: ()=>HttpClientError_namespaceObject,
+    Layer: ()=>Layer_namespaceObject,
+    Rpc: ()=>rpc_namespaceObject.Rpc,
+    RpcClient: ()=>rpc_namespaceObject.RpcClient,
+    RpcGroup: ()=>rpc_namespaceObject.RpcGroup,
+    RpcSchema: ()=>rpc_namespaceObject.RpcSchema,
+    RpcSerialization: ()=>rpc_namespaceObject.RpcSerialization,
+    Schema: ()=>Schema_namespaceObject,
+    makeEffectHttpApiClient: ()=>makeEffectHttpApiClient,
+    makeEffectRpcClient: ()=>makeEffectRpcClient,
+    mask: ()=>mask,
+    runEffectRequest: ()=>runEffectRequest,
+    runEffectView: ()=>runEffectView,
+    view: ()=>view
+});
+const create_request_namespaceObject = require("@modern-js/create-request");
+const Data_namespaceObject = require("effect/Data");
+const Effect_namespaceObject = require("effect/Effect");
+const Exit_namespaceObject = require("effect/Exit");
+const Layer_namespaceObject = require("effect/Layer");
+const ManagedRuntime_namespaceObject = require("effect/ManagedRuntime");
+const Scope_namespaceObject = require("effect/Scope");
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const rpc_namespaceObject = require("effect/unstable/rpc");
+const rpcSerialization_js_namespaceObject = require("../effect/rpcSerialization.js");
+const Schema_namespaceObject = require("effect/Schema");
+const HttpClientError_namespaceObject = require("effect/unstable/http/HttpClientError");
+class EffectRpcClientError extends Data_namespaceObject.TaggedError('EffectRpcClientError') {
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function applySelection(value, selection) {
+    if (true === selection || void 0 === selection) return value;
+    if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
+    if (!isRecord(value) || !isRecord(selection)) return value;
+    const masked = {};
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
+    }
+    return masked;
+}
+function view() {
+    return (selection)=>selection;
+}
+function mask(value, selection) {
+    return applySelection(value, selection);
+}
+function runEffectView(request, selection) {
+    return new Promise((resolve, reject)=>{
+        request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
+    });
+}
+function makeEffectHttpApiClient(api, options) {
+    const requestContextHeaders = (0, create_request_namespaceObject.createRequestContextHeaders)(options?.requestContext);
+    const transformClient = (client)=>{
+        const contextClient = 0 === Object.keys(requestContextHeaders).length ? client : client.pipe(http_namespaceObject.HttpClient.mapRequest((request)=>{
+            let nextRequest = request;
+            for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = http_namespaceObject.HttpClientRequest.setHeader(nextRequest, header, value);
+            return nextRequest;
+        }));
+        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
+    };
+    return httpapi_namespaceObject.HttpApiClient.make(api, {
+        baseUrl: options?.baseUrl,
+        transformClient,
+        transformResponse: options?.transformResponse
+    }).pipe(Effect_namespaceObject.provide(http_namespaceObject.FetchHttpClient.layer));
+}
+function makeEffectRpcClient(group, options) {
+    const protocolLayer = Layer_namespaceObject.provide(rpc_namespaceObject.RpcClient.layerProtocolHttp({
+        url: options.url
+    }), Layer_namespaceObject.mergeAll((0, rpcSerialization_js_namespaceObject.getRpcSerializationLayer)(options.serialization), http_namespaceObject.FetchHttpClient.layer));
+    const middlewareLayer = options.middlewareLayer ?? Layer_namespaceObject.empty;
+    const runtimeLayer = Layer_namespaceObject.mergeAll(protocolLayer, middlewareLayer);
+    return Effect_namespaceObject.tryPromise({
+        try: async ()=>{
+            const runtime = ManagedRuntime_namespaceObject.make(runtimeLayer);
+            let scope;
+            try {
+                const clientScope = await runtime.runPromise(Scope_namespaceObject.make());
+                scope = clientScope;
+                const client = await runtime.runPromise(rpc_namespaceObject.RpcClient.make(group, {
+                    flatten: options.flatten
+                }).pipe(Effect_namespaceObject.provideService(Scope_namespaceObject.Scope, clientScope)));
+                let disposePromise;
+                const clientWithDispose = Object.assign(client, {
+                    dispose: ()=>{
+                        disposePromise ??= (async ()=>{
+                            let scopeCloseError;
+                            try {
+                                await runtime.runPromise(Scope_namespaceObject.close(clientScope, Exit_namespaceObject["void"]));
+                            } catch (error) {
+                                scopeCloseError = error;
+                            }
+                            try {
+                                await runtime.dispose();
+                            } catch (error) {
+                                if (void 0 === scopeCloseError) throw error;
+                            }
+                            if (void 0 !== scopeCloseError) throw scopeCloseError;
+                        })();
+                        return disposePromise;
+                    }
+                });
+                return clientWithDispose;
+            } catch (error) {
+                if (void 0 !== scope) try {
+                    await runtime.runPromise(Scope_namespaceObject.close(scope, Exit_namespaceObject["void"]));
+                } catch  {}
+                try {
+                    await runtime.dispose();
+                } catch  {}
+                throw error;
+            }
+        },
+        catch: (error)=>new EffectRpcClientError({
+                cause: error
+            })
+    });
+}
+const runEffectRequest = Effect_namespaceObject.runPromise;
+exports.Effect = __webpack_exports__.Effect;
+exports.EffectRpcClientError = __webpack_exports__.EffectRpcClientError;
+exports.HttpApi = __webpack_exports__.HttpApi;
+exports.HttpApiClient = __webpack_exports__.HttpApiClient;
+exports.HttpApiEndpoint = __webpack_exports__.HttpApiEndpoint;
+exports.HttpApiGroup = __webpack_exports__.HttpApiGroup;
+exports.HttpApiSchema = __webpack_exports__.HttpApiSchema;
+exports.HttpClientError = __webpack_exports__.HttpClientError;
+exports.Layer = __webpack_exports__.Layer;
+exports.Rpc = __webpack_exports__.Rpc;
+exports.RpcClient = __webpack_exports__.RpcClient;
+exports.RpcGroup = __webpack_exports__.RpcGroup;
+exports.RpcSchema = __webpack_exports__.RpcSchema;
+exports.RpcSerialization = __webpack_exports__.RpcSerialization;
+exports.Schema = __webpack_exports__.Schema;
+exports.makeEffectHttpApiClient = __webpack_exports__.makeEffectHttpApiClient;
+exports.makeEffectRpcClient = __webpack_exports__.makeEffectRpcClient;
+exports.mask = __webpack_exports__.mask;
+exports.runEffectRequest = __webpack_exports__.runEffectRequest;
+exports.runEffectView = __webpack_exports__.runEffectView;
+exports.view = __webpack_exports__.view;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Effect",
+    "EffectRpcClientError",
+    "HttpApi",
+    "HttpApiClient",
+    "HttpApiEndpoint",
+    "HttpApiGroup",
+    "HttpApiSchema",
+    "HttpClientError",
+    "Layer",
+    "Rpc",
+    "RpcClient",
+    "RpcGroup",
+    "RpcSchema",
+    "RpcSerialization",
+    "Schema",
+    "makeEffectHttpApiClient",
+    "makeEffectRpcClient",
+    "mask",
+    "runEffectRequest",
+    "runEffectView",
+    "view"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/request-context.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__, {
+    applyRequestContext: ()=>applyRequestContext,
+    createEffectRequestContext: ()=>createEffectRequestContext
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const createEffectRequestContext = (createRequestContextHeaders, requestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(requestContext)) return {};
+    const headers = createRequestContextHeaders ? createRequestContextHeaders(requestContext) : {};
+    return {
+        ...requestContext,
+        headers
+    };
+};
+const applyRequestContext = (normalizedRequest, request, createRequestContext)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request) || !(0, external_guards_js_namespaceObject.isRecord)(request.requestContext)) return normalizedRequest;
+    const requestContext = createRequestContext(request.requestContext);
+    const requestHeaders = (0, external_guards_js_namespaceObject.isRecord)(requestContext.headers) ? requestContext.headers : {};
+    if (0 === Object.keys(requestHeaders).length) return normalizedRequest;
+    return {
+        ...normalizedRequest,
+        headers: {
+            ...(0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.headers) ? normalizedRequest.headers : {},
+            ...requestHeaders
+        }
+    };
+};
+exports.applyRequestContext = __webpack_exports__.applyRequestContext;
+exports.createEffectRequestContext = __webpack_exports__.createEffectRequestContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRequestContext",
+    "createEffectRequestContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/request.js

@@ -0,0 +1,66 @@
+"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__, {
+    normalizeRequest: ()=>normalizeRequest
+});
+const external_guards_js_namespaceObject = require("./guards.js");
+const METHODS_WITHOUT_BODY = new Set([
+    'GET',
+    'DELETE',
+    'HEAD',
+    'OPTIONS'
+]);
+const normalizeRequest = (method, request)=>{
+    if (!(0, external_guards_js_namespaceObject.isRecord)(request)) return {};
+    const payload = {
+        ...request
+    };
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.path) && !(0, external_guards_js_namespaceObject.isRecord)(payload.params)) payload.params = request.path;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.urlParams) && !(0, external_guards_js_namespaceObject.isRecord)(payload.query)) payload.query = request.urlParams;
+    if ((0, external_guards_js_namespaceObject.isRecord)(request.headers) && !(0, external_guards_js_namespaceObject.isRecord)(payload.headers)) payload.headers = request.headers;
+    if ('payload' in request && void 0 !== request.payload) if ("u" > typeof FormData && request.payload instanceof FormData && !('formData' in payload)) payload.formData = request.payload;
+    else if (METHODS_WITHOUT_BODY.has(method)) {
+        if ((0, external_guards_js_namespaceObject.isRecord)(request.payload)) payload.query = (0, external_guards_js_namespaceObject.isRecord)(payload.query) ? {
+            ...payload.query,
+            ...request.payload
+        } : request.payload;
+        else if (!('body' in payload)) payload.body = request.payload;
+    } else if (!(0, external_guards_js_namespaceObject.isRecord)(request.payload) || 'data' in payload) {
+        if (!('body' in payload)) payload.body = request.payload;
+    } else payload.data = request.payload;
+    return payload;
+};
+exports.normalizeRequest = __webpack_exports__.normalizeRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/runtime.js

@@ -0,0 +1,100 @@
+"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__, {
+    createGeneratedEffectClient: ()=>createGeneratedEffectClient
+});
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_request_context_js_namespaceObject = require("./request-context.js");
+const createGeneratedEffectClient = (manifest, config, requestRuntime)=>{
+    const createRequest = requestRuntime.createRequest;
+    const configureRequest = 'function' == typeof requestRuntime.configure ? requestRuntime.configure : void 0;
+    const createRequestContextHeaders = 'function' == typeof requestRuntime.createRequestContextHeaders ? requestRuntime.createRequestContextHeaders : void 0;
+    const httpMethodDecider = config.httpMethodDecider || 'functionName';
+    const port = config.useEnvPort && "u" > typeof process && process.env && process.env.PORT ? process.env.PORT : config.port;
+    (0, external_batch_js_namespaceObject.configureGeneratedEffectClientRuntime)(config, configureRequest);
+    const createEffectRequestContext = (requestContext)=>(0, external_request_context_js_namespaceObject.createEffectRequestContext)(createRequestContextHeaders, requestContext);
+    const client = {};
+    const operationManifest = {};
+    for (const endpoint of manifest.endpoints){
+        const operationId = `${endpoint.method}:${endpoint.routePath}`;
+        const operation = {
+            appNamespace: config.appNamespace,
+            apiId: endpoint.apiId,
+            group: endpoint.group,
+            endpoint: endpoint.endpoint,
+            operationId,
+            routePath: endpoint.routePath,
+            method: endpoint.method,
+            operationVersion: endpoint.operationVersion,
+            schemaHash: endpoint.schemaHash,
+            version: endpoint.operationVersion
+        };
+        const sender = createRequest({
+            path: endpoint.routePath,
+            method: endpoint.method,
+            port,
+            operationContext: {
+                operationId,
+                routePath: endpoint.routePath,
+                method: endpoint.method,
+                schemaHash: endpoint.schemaHash,
+                operationVersion: endpoint.operationVersion
+            },
+            httpMethodDecider,
+            ...config.requestId ? {
+                requestId: config.requestId
+            } : {}
+        });
+        const call = (request = {})=>sender((0, external_envelope_js_namespaceObject.prepareEffectRequest)({
+                endpoint,
+                operation,
+                request,
+                config,
+                createEffectRequestContext
+            }));
+        client[endpoint.group] ??= {};
+        client[endpoint.group][endpoint.endpoint] = call;
+        operationManifest[endpoint.group] ??= {};
+        operationManifest[endpoint.group][endpoint.endpoint] = operation;
+    }
+    return {
+        client,
+        operationManifest,
+        createEffectRequestContext
+    };
+};
+exports.createGeneratedEffectClient = __webpack_exports__.createGeneratedEffectClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createGeneratedEffectClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect-client/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/headers.js

@@ -0,0 +1,46 @@
+"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/cjs/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_modules__ = {
+    "./data-platform" (module) {
+        module.exports = require("./data-platform/index.js");
+    },
+    "./effect-client" (module) {
+        module.exports = require("./effect-client/index.js");
+    },
+    "./effect" (module) {
+        module.exports = require("./effect/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _data_platform__rspack_import_0 = __webpack_require__("./data-platform");
+    var _effect__rspack_import_1 = __webpack_require__("./effect");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _effect__rspack_import_1)if ([
+        "EffectClient",
+        "DataPlatform",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_effect__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _effect_client__rspack_import_2 = __webpack_require__("./effect-client");
+    __webpack_require__.d(__webpack_exports__, {
+        DataPlatform: ()=>_data_platform__rspack_import_0,
+        EffectClient: ()=>_effect_client__rspack_import_2
+    });
+})();
+exports.DataPlatform = __webpack_exports__.DataPlatform;
+exports.EffectClient = __webpack_exports__.EffectClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DataPlatform",
+    "EffectClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,71 @@
+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 };