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

package/dist/cjs/effect/handler/http.js

@@ -0,0 +1,107 @@
+"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__, {
+    createHttpApiHandler: ()=>createHttpApiHandler
+});
+const Layer_namespaceObject = require("effect/Layer");
+const http_namespaceObject = require("effect/unstable/http");
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_batch_handler_js_namespaceObject = require("./batch-handler.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_openapi_js_namespaceObject = require("./openapi.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+const external_rpc_js_namespaceObject = require("./rpc.js");
+const external_types_js_namespaceObject = require("./types.js");
+function createHttpApiHandler(options) {
+    const apiLayer = options.layer.pipe(Layer_namespaceObject.provide(http_namespaceObject.HttpServer.layerServices));
+    const openApiLayer = (0, external_openapi_js_namespaceObject.createOpenApiLayer)(options.api, options.openapi);
+    const mergedLayer = openApiLayer ? Layer_namespaceObject.mergeAll(apiLayer, openApiLayer) : apiLayer;
+    const httpApiHandler = http_namespaceObject.HttpRouter.toWebHandler(mergedLayer);
+    const dispatchHttpApiRequest = async (request, context)=>{
+        const preparedRequest = await (0, external_batch_js_namespaceObject.prepareJsonRequestBody)(request);
+        if (preparedRequest instanceof Response) return preparedRequest;
+        const validationError = (0, external_envelope_js_namespaceObject.validateDataPlatformRequestEnvelope)(preparedRequest, options.dataPlatform);
+        if (validationError) return validationError;
+        return httpApiHandler.handler(preparedRequest, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+    };
+    const withRequestPolicy = async (request, context)=>{
+        const policyDenial = options.validateRequest?.(request);
+        if (policyDenial) return policyDenial;
+        const next = ()=>dispatchHttpApiRequest(request, context);
+        return options.interceptRequest ? options.interceptRequest({
+            request,
+            next
+        }) : next();
+    };
+    const batchHandler = (0, external_batch_handler_js_namespaceObject.createDataPlatformBatchRequestHandler)({
+        dataPlatform: options.dataPlatform,
+        handleItem: withRequestPolicy
+    });
+    const handleHttpApiRequest = async (request, context)=>{
+        const pathname = (0, external_routing_js_namespaceObject.getRequestPathname)(request);
+        if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
+        return withRequestPolicy(request, context);
+    };
+    if (!options.rpc) return {
+        handler: handleHttpApiRequest,
+        dispose: async ()=>{
+            await httpApiHandler.dispose();
+        }
+    };
+    const rpcPath = (0, external_rpc_js_namespaceObject.normalizeRpcPath)(options.rpc.path);
+    const rpcHandler = (0, external_rpc_js_namespaceObject.createRpcApiHandler)(options.rpc);
+    return {
+        handler: async (request, context)=>{
+            if ((0, external_routing_js_namespaceObject.isRpcRequest)(request, rpcPath)) {
+                const policyDenial = options.validateRequest?.(request);
+                if (policyDenial) return policyDenial;
+                const next = ()=>rpcHandler.handler(request, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+                return options.interceptRequest ? options.interceptRequest({
+                    request,
+                    next
+                }) : next();
+            }
+            return handleHttpApiRequest(request, context);
+        },
+        dispose: async ()=>{
+            await Promise.all([
+                httpApiHandler.dispose(),
+                rpcHandler.dispose()
+            ]);
+        }
+    };
+}
+exports.createHttpApiHandler = __webpack_exports__.createHttpApiHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHttpApiHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler/openapi.js

@@ -0,0 +1,58 @@
+"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__, {
+    createOpenApiLayer: ()=>createOpenApiLayer
+});
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const DEFAULT_OPENAPI_PATH = '/openapi.json';
+function normalizeOpenApiPath(pathname) {
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function getOpenApiOptions(openapi) {
+    if (false === openapi || void 0 === openapi) return;
+    const path = true === openapi ? DEFAULT_OPENAPI_PATH : openapi.path;
+    return {
+        path: normalizeOpenApiPath(path ?? DEFAULT_OPENAPI_PATH)
+    };
+}
+function createOpenApiLayer(api, openapi) {
+    const openApiOptions = getOpenApiOptions(openapi);
+    if (!openApiOptions) return null;
+    return http_namespaceObject.HttpRouter.add('GET', openApiOptions.path, http_namespaceObject.HttpServerResponse.jsonUnsafe(httpapi_namespaceObject.OpenApi.fromApi(api)));
+}
+exports.createOpenApiLayer = __webpack_exports__.createOpenApiLayer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOpenApiLayer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler/routing.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__, {
+    getExpectedEnvelopeOrigin: ()=>getExpectedEnvelopeOrigin,
+    getMountedPrefixFromContext: ()=>getMountedPrefixFromContext,
+    getRequestPathname: ()=>getRequestPathname,
+    isRpcRequest: ()=>isRpcRequest,
+    removeMountedPrefixFromBatchPath: ()=>removeMountedPrefixFromBatchPath
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+function getRequestPathname(request) {
+    try {
+        return new URL(request.url).pathname;
+    } catch  {
+        return new URL(request.url, 'http://localhost').pathname;
+    }
+}
+function normalizeMountPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function getMountedPrefixFromContext(request, context) {
+    if (!(0, index_js_namespaceObject.isPlainObject)(context) || 'string' != typeof context.path) return '';
+    const contextPath = normalizeMountPrefix(context.path);
+    const requestPath = normalizeMountPrefix(getRequestPathname(request));
+    if (!contextPath || !requestPath || contextPath === requestPath || !contextPath.endsWith(requestPath)) return '';
+    return normalizeMountPrefix(contextPath.slice(0, contextPath.length - requestPath.length));
+}
+function removeMountedPrefixFromBatchPath(pathWithQuery, prefix) {
+    const normalizedPrefix = normalizeMountPrefix(prefix);
+    if (!normalizedPrefix) return pathWithQuery;
+    const [pathname, ...queryParts] = pathWithQuery.split('?');
+    if (!pathname) return pathWithQuery;
+    let nextPathname = pathname;
+    if (pathname === normalizedPrefix) nextPathname = '/';
+    else if (pathname.startsWith(`${normalizedPrefix}/`)) {
+        const sliced = pathname.slice(normalizedPrefix.length);
+        nextPathname = sliced.startsWith('/') ? sliced : `/${sliced}`;
+    }
+    if (0 === queryParts.length) return nextPathname;
+    return `${nextPathname}?${queryParts.join('?')}`;
+}
+function getRequestOrigin(request) {
+    try {
+        return new URL(request.url).origin;
+    } catch  {
+        return new URL(request.url, 'http://localhost').origin;
+    }
+}
+function getExpectedEnvelopeOrigin(request) {
+    const origin = request.headers.get('origin');
+    if (origin && 'null' !== origin) return origin;
+    return getRequestOrigin(request);
+}
+function isRpcRequest(request, rpcPath) {
+    const pathname = getRequestPathname(request);
+    return pathname === rpcPath || pathname.startsWith(`${rpcPath}/`);
+}
+exports.getExpectedEnvelopeOrigin = __webpack_exports__.getExpectedEnvelopeOrigin;
+exports.getMountedPrefixFromContext = __webpack_exports__.getMountedPrefixFromContext;
+exports.getRequestPathname = __webpack_exports__.getRequestPathname;
+exports.isRpcRequest = __webpack_exports__.isRpcRequest;
+exports.removeMountedPrefixFromBatchPath = __webpack_exports__.removeMountedPrefixFromBatchPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getExpectedEnvelopeOrigin",
+    "getMountedPrefixFromContext",
+    "getRequestPathname",
+    "isRpcRequest",
+    "removeMountedPrefixFromBatchPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler/rpc.js

@@ -0,0 +1,63 @@
+"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__, {
+    createRpcApiHandler: ()=>createRpcApiHandler,
+    normalizeRpcPath: ()=>normalizeRpcPath
+});
+const Layer_namespaceObject = require("effect/Layer");
+const http_namespaceObject = require("effect/unstable/http");
+const rpc_namespaceObject = require("effect/unstable/rpc");
+const external_rpcSerialization_js_namespaceObject = require("../rpcSerialization.js");
+function normalizeRpcPath(pathname) {
+    if (!pathname || '/' === pathname) return '/rpc';
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function createRpcApiHandler(options) {
+    const rpcPath = normalizeRpcPath(options.path);
+    const rpcLayer = Layer_namespaceObject.provide(rpc_namespaceObject.RpcServer.layerHttp({
+        group: options.group,
+        path: rpcPath,
+        protocol: 'http',
+        disableTracing: options.disableTracing,
+        spanPrefix: options.spanPrefix,
+        spanAttributes: options.spanAttributes
+    }), Layer_namespaceObject.mergeAll(options.layer, (0, external_rpcSerialization_js_namespaceObject.getRpcSerializationLayer)(options.serialization)));
+    return http_namespaceObject.HttpRouter.toWebHandler(rpcLayer);
+}
+exports.createRpcApiHandler = __webpack_exports__.createRpcApiHandler;
+exports.normalizeRpcPath = __webpack_exports__.normalizeRpcPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRpcApiHandler",
+    "normalizeRpcPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler/types.js

@@ -0,0 +1,43 @@
+"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__, {
+    toEffectServiceContext: ()=>toEffectServiceContext
+});
+const Context_namespaceObject = require("effect/Context");
+const emptyEffectServiceContext = Context_namespaceObject.empty();
+const isEffectServiceContext = (context)=>'object' == typeof context && null !== context && 'mapUnsafe' in context;
+const toEffectServiceContext = (context)=>isEffectServiceContext(context) ? context : emptyEffectServiceContext;
+exports.toEffectServiceContext = __webpack_exports__.toEffectServiceContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "toEffectServiceContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/handler.js

@@ -0,0 +1,173 @@
+"use strict";
+var __webpack_modules__ = {
+    "./handler/definition" (module) {
+        module.exports = require("./handler/definition.js");
+    },
+    "./handler/http" (module) {
+        module.exports = require("./handler/http.js");
+    },
+    "effect/Config" (module) {
+        module.exports = require("effect/Config");
+    },
+    "effect/Effect" (module) {
+        module.exports = require("effect/Effect");
+    },
+    "effect/Layer" (module) {
+        module.exports = require("effect/Layer");
+    },
+    "effect/Option" (module) {
+        module.exports = require("effect/Option");
+    },
+    "effect/Schema" (module) {
+        module.exports = require("effect/Schema");
+    },
+    "effect/unstable/http" (module) {
+        module.exports = require("effect/unstable/http");
+    },
+    "effect/unstable/httpapi" (module) {
+        module.exports = require("effect/unstable/httpapi");
+    },
+    "effect/unstable/rpc" (module) {
+        module.exports = require("effect/unstable/rpc");
+    }
+};
+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 effect_Config__rspack_import_0 = __webpack_require__("effect/Config");
+    var effect_Effect__rspack_import_1 = __webpack_require__("effect/Effect");
+    var effect_Layer__rspack_import_2 = __webpack_require__("effect/Layer");
+    var effect_Option__rspack_import_3 = __webpack_require__("effect/Option");
+    var effect_Schema__rspack_import_4 = __webpack_require__("effect/Schema");
+    var effect_unstable_http__rspack_import_5 = __webpack_require__("effect/unstable/http");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_http__rspack_import_5)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "defineEffectBff",
+        "default",
+        "Effect",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_http__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var effect_unstable_httpapi__rspack_import_6 = __webpack_require__("effect/unstable/httpapi");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_httpapi__rspack_import_6)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "defineEffectBff",
+        "default",
+        "Effect",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_httpapi__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var effect_unstable_rpc__rspack_import_7 = __webpack_require__("effect/unstable/rpc");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in effect_unstable_rpc__rspack_import_7)if ([
+        "Config",
+        "Layer",
+        "Schema",
+        "HttpTraceContext",
+        "HttpApiBuilder",
+        "defineEffectBff",
+        "default",
+        "Effect",
+        "defineEffectRpcBff",
+        "createHttpApiHandler",
+        "Option"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>effect_unstable_rpc__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _handler_definition__rspack_import_8 = __webpack_require__("./handler/definition");
+    var _handler_http__rspack_import_9 = __webpack_require__("./handler/http");
+    __webpack_require__.d(__webpack_exports__, {
+        Config: ()=>effect_Config__rspack_import_0,
+        Effect: ()=>effect_Effect__rspack_import_1,
+        HttpApiBuilder: ()=>effect_unstable_httpapi__rspack_import_6.HttpApiBuilder,
+        HttpTraceContext: ()=>effect_unstable_http__rspack_import_5.HttpTraceContext,
+        Layer: ()=>effect_Layer__rspack_import_2,
+        Option: ()=>effect_Option__rspack_import_3,
+        Schema: ()=>effect_Schema__rspack_import_4,
+        createHttpApiHandler: ()=>_handler_http__rspack_import_9.createHttpApiHandler,
+        defineEffectBff: ()=>_handler_definition__rspack_import_8.defineEffectBff,
+        defineEffectRpcBff: ()=>_handler_definition__rspack_import_8.defineEffectRpcBff
+    });
+})();
+exports.Config = __webpack_exports__.Config;
+exports.Effect = __webpack_exports__.Effect;
+exports.HttpApiBuilder = __webpack_exports__.HttpApiBuilder;
+exports.HttpTraceContext = __webpack_exports__.HttpTraceContext;
+exports.Layer = __webpack_exports__.Layer;
+exports.Option = __webpack_exports__.Option;
+exports.Schema = __webpack_exports__.Schema;
+exports.createHttpApiHandler = __webpack_exports__.createHttpApiHandler;
+exports.defineEffectBff = __webpack_exports__.defineEffectBff;
+exports.defineEffectRpcBff = __webpack_exports__.defineEffectRpcBff;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Config",
+    "Effect",
+    "HttpApiBuilder",
+    "HttpTraceContext",
+    "Layer",
+    "Option",
+    "Schema",
+    "createHttpApiHandler",
+    "defineEffectBff",
+    "defineEffectRpcBff"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/effect/index.js

@@ -0,0 +1,137 @@
+"use strict";
+var __webpack_modules__ = {
+    "./context" (module) {
+        module.exports = require("./context.js");
+    },
+    "./edge" (module) {
+        module.exports = require("./edge.js");
+    },
+    "./endpoint-contracts" (module) {
+        module.exports = require("./endpoint-contracts.js");
+    },
+    "./handler" (module) {
+        module.exports = require("./handler.js");
+    },
+    "./module" (module) {
+        module.exports = require("./module.js");
+    },
+    "@effect/opentelemetry" (module) {
+        module.exports = require("@effect/opentelemetry");
+    }
+};
+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 _effect_opentelemetry__rspack_import_0 = __webpack_require__("@effect/opentelemetry");
+    var _context__rspack_import_1 = __webpack_require__("./context");
+    var _edge__rspack_import_2 = __webpack_require__("./edge");
+    var _endpoint_contracts__rspack_import_3 = __webpack_require__("./endpoint-contracts");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _endpoint_contracts__rspack_import_3)if ([
+        "runWithEffectContext",
+        "useEffectContext",
+        "resolveEffectBffModuleHandler",
+        "useOperationContext",
+        "createEffectOperationContext",
+        "dispatchEffectBffRequest",
+        "default",
+        "createEffectBffTestHandler",
+        "OpenTelemetry",
+        "createEffectBffEdgeHandler"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_endpoint_contracts__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _handler__rspack_import_4 = __webpack_require__("./handler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _handler__rspack_import_4)if ([
+        "runWithEffectContext",
+        "useEffectContext",
+        "resolveEffectBffModuleHandler",
+        "useOperationContext",
+        "createEffectOperationContext",
+        "dispatchEffectBffRequest",
+        "default",
+        "createEffectBffTestHandler",
+        "OpenTelemetry",
+        "createEffectBffEdgeHandler"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _module__rspack_import_5 = __webpack_require__("./module");
+    __webpack_require__.d(__webpack_exports__, {
+        OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_0,
+        createEffectBffEdgeHandler: ()=>_edge__rspack_import_2.createEffectBffEdgeHandler,
+        createEffectBffTestHandler: ()=>_edge__rspack_import_2.createEffectBffTestHandler,
+        createEffectOperationContext: ()=>_context__rspack_import_1.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>_edge__rspack_import_2.dispatchEffectBffRequest,
+        resolveEffectBffModuleHandler: ()=>_module__rspack_import_5.resolveEffectBffModuleHandler,
+        runWithEffectContext: ()=>_context__rspack_import_1.runWithEffectContext,
+        useEffectContext: ()=>_context__rspack_import_1.useEffectContext,
+        useOperationContext: ()=>_context__rspack_import_1.useOperationContext
+    });
+})();
+exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;
+exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
+exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
+exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
+exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.resolveEffectBffModuleHandler = __webpack_exports__.resolveEffectBffModuleHandler;
+exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
+exports.useEffectContext = __webpack_exports__.useEffectContext;
+exports.useOperationContext = __webpack_exports__.useOperationContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OpenTelemetry",
+    "createEffectBffEdgeHandler",
+    "createEffectBffTestHandler",
+    "createEffectOperationContext",
+    "dispatchEffectBffRequest",
+    "resolveEffectBffModuleHandler",
+    "runWithEffectContext",
+    "useEffectContext",
+    "useOperationContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});