pi-cursor-sdk 0.1.12 → 0.1.13

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/handler-factory.js

@@ -1,278 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Message, MethodIdempotency, MethodKind, protoBase64, } from "@bufbuild/protobuf";
-import { Code } from "../code.js";
-import { ConnectError } from "../connect-error.js";
-import { createHandlerContext } from "../implementation.js";
-import { contentTypeStreamJson, contentTypeStreamProto, contentTypeStreamRegExp, contentTypeUnaryJson, contentTypeUnaryProto, contentTypeUnaryRegExp, parseContentType, parseEncodingQuery, } from "./content-type.js";
-import { createEndStreamSerialization, endStreamFlag } from "./end-stream.js";
-import { errorToJsonBytes } from "./error-json.js";
-import { headerContentType, headerStreamAcceptEncoding, headerStreamEncoding, headerTimeout, headerUnaryAcceptEncoding, headerUnaryContentLength, headerUnaryEncoding, } from "./headers.js";
-import { codeToHttpStatus } from "./http-status.js";
-import { parseTimeout } from "./parse-timeout.js";
-import { paramBase64, paramCompression, paramEncoding, paramMessage, } from "./query-params.js";
-import { trailerMux } from "./trailer-mux.js";
-import { requireProtocolVersionHeader, requireProtocolVersionParam, } from "./version.js";
-import { compressionNegotiate } from "../protocol/compression.js";
-import { createMethodSerializationLookup } from "../protocol/serialization.js";
-import { validateUniversalHandlerOptions } from "../protocol/universal-handler.js";
-import { assertByteStreamRequest, uResponseMethodNotAllowed, uResponseOk, uResponseUnsupportedMediaType, } from "../protocol/universal.js";
-import { createAsyncIterable, pipe, readAllBytes, transformCatchFinally, transformCompressEnvelope, transformDecompressEnvelope, transformJoinEnvelopes, transformParseEnvelope, transformPrepend, transformSerializeEnvelope, transformSplitEnvelope, untilFirst, } from "../protocol/async-iterable.js";
-import { contentTypeMatcher } from "../protocol/content-type-matcher.js";
-import { createMethodUrl } from "../protocol/create-method-url.js";
-import { invokeUnaryImplementation, transformInvokeImplementation, } from "../protocol/invoke-implementation.js";
-const protocolName = "connect";
-const methodPost = "POST";
-const methodGet = "GET";
-/**
- * Create a factory that creates Connect handlers.
- */
-export function createHandlerFactory(options) {
-    const opt = validateUniversalHandlerOptions(options);
-    const endStreamSerialization = createEndStreamSerialization(opt.jsonOptions);
-    function fact(spec) {
-        let h;
-        let contentTypeRegExp;
-        const serialization = createMethodSerializationLookup(spec.method, opt.binaryOptions, opt.jsonOptions, opt);
-        switch (spec.kind) {
-            case MethodKind.Unary:
-                contentTypeRegExp = contentTypeUnaryRegExp;
-                h = createUnaryHandler(opt, spec, serialization);
-                break;
-            default:
-                contentTypeRegExp = contentTypeStreamRegExp;
-                h = createStreamHandler(opt, spec, serialization, endStreamSerialization);
-                break;
-        }
-        const allowedMethods = [methodPost];
-        if (spec.method.idempotency === MethodIdempotency.NoSideEffects) {
-            allowedMethods.push(methodGet);
-        }
-        return Object.assign(h, {
-            protocolNames: [protocolName],
-            supportedContentType: contentTypeMatcher(contentTypeRegExp),
-            allowedMethods,
-            requestPath: createMethodUrl("/", spec.service, spec.method),
-            service: spec.service,
-            method: spec.method,
-        });
-    }
-    fact.protocolName = protocolName;
-    return fact;
-}
-function createUnaryHandler(opt, spec, serialization) {
-    return async function handle(req) {
-        const isGet = req.method == methodGet;
-        if (isGet && spec.method.idempotency != MethodIdempotency.NoSideEffects) {
-            return uResponseMethodNotAllowed;
-        }
-        const queryParams = new URL(req.url).searchParams;
-        const compressionRequested = isGet
-            ? queryParams.get(paramCompression)
-            : req.header.get(headerUnaryEncoding);
-        const type = isGet
-            ? parseEncodingQuery(queryParams.get(paramEncoding))
-            : parseContentType(req.header.get(headerContentType));
-        if (type == undefined || type.stream) {
-            return uResponseUnsupportedMediaType;
-        }
-        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
-        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
-                [headerContentType]: type.binary
-                    ? contentTypeUnaryProto
-                    : contentTypeUnaryJson,
-            }, contextValues: req.contextValues }));
-        const compression = compressionNegotiate(opt.acceptCompression, compressionRequested, req.header.get(headerUnaryAcceptEncoding), headerUnaryAcceptEncoding);
-        let status = uResponseOk.status;
-        let body;
-        try {
-            if (opt.requireConnectProtocolHeader) {
-                if (isGet) {
-                    requireProtocolVersionParam(queryParams);
-                }
-                else {
-                    requireProtocolVersionHeader(req.header);
-                }
-            }
-            // raise compression error to serialize it as a error response
-            if (compression.error) {
-                throw compression.error;
-            }
-            // raise timeout parsing error to serialize it as a trailer status
-            if (timeout.error) {
-                throw timeout.error;
-            }
-            let reqBody;
-            if (isGet) {
-                reqBody = await readUnaryMessageFromQuery(opt.readMaxBytes, compression.request, queryParams);
-            }
-            else {
-                reqBody = await readUnaryMessageFromBody(opt.readMaxBytes, compression.request, req);
-            }
-            const input = parseUnaryMessage(spec.method, type.binary, serialization, reqBody);
-            const output = await invokeUnaryImplementation(spec, context, input, opt.interceptors);
-            body = serialization.getO(type.binary).serialize(output);
-        }
-        catch (e) {
-            let error;
-            if (e instanceof ConnectError) {
-                error = e;
-            }
-            else {
-                error = new ConnectError("internal error", Code.Internal, undefined, undefined, e);
-            }
-            status = codeToHttpStatus(error.code);
-            context.responseHeader.set(headerContentType, contentTypeUnaryJson);
-            error.metadata.forEach((value, key) => {
-                context.responseHeader.set(key, value);
-            });
-            body = errorToJsonBytes(error, opt.jsonOptions);
-        }
-        finally {
-            context.abort();
-        }
-        if (compression.response && body.byteLength >= opt.compressMinBytes) {
-            body = await compression.response.compress(body);
-            context.responseHeader.set(headerUnaryEncoding, compression.response.name);
-        }
-        const header = trailerMux(context.responseHeader, context.responseTrailer);
-        header.set(headerUnaryContentLength, body.byteLength.toString(10));
-        return {
-            status,
-            body: createAsyncIterable([body]),
-            header,
-        };
-    };
-}
-async function readUnaryMessageFromBody(readMaxBytes, compression, request) {
-    if (typeof request.body == "object" &&
-        request.body !== null &&
-        Symbol.asyncIterator in request.body) {
-        let reqBytes = await readAllBytes(request.body, readMaxBytes, request.header.get(headerUnaryContentLength));
-        if (compression) {
-            reqBytes = await compression.decompress(reqBytes, readMaxBytes);
-        }
-        return reqBytes;
-    }
-    return request.body;
-}
-async function readUnaryMessageFromQuery(readMaxBytes, compression, queryParams) {
-    var _a;
-    const base64 = queryParams.get(paramBase64);
-    const message = (_a = queryParams.get(paramMessage)) !== null && _a !== void 0 ? _a : "";
-    let decoded;
-    if (base64 === "1") {
-        decoded = protoBase64.dec(message);
-    }
-    else {
-        decoded = new TextEncoder().encode(message);
-    }
-    if (compression) {
-        decoded = await compression.decompress(decoded, readMaxBytes);
-    }
-    return decoded;
-}
-function parseUnaryMessage(method, useBinaryFormat, serialization, input) {
-    if (input instanceof Uint8Array) {
-        return serialization.getI(useBinaryFormat).parse(input);
-    }
-    if (useBinaryFormat) {
-        throw new ConnectError("received parsed JSON request body, but content-type indicates binary format", Code.Internal);
-    }
-    try {
-        return method.I.fromJson(input);
-    }
-    catch (e) {
-        throw ConnectError.from(e, Code.InvalidArgument);
-    }
-}
-function createStreamHandler(opt, spec, serialization, endStreamSerialization) {
-    return async function handle(req) {
-        assertByteStreamRequest(req);
-        const type = parseContentType(req.header.get(headerContentType));
-        if (type == undefined || !type.stream) {
-            return uResponseUnsupportedMediaType;
-        }
-        if (req.method !== methodPost) {
-            return uResponseMethodNotAllowed;
-        }
-        const timeout = parseTimeout(req.header.get(headerTimeout), opt.maxTimeoutMs);
-        const context = createHandlerContext(Object.assign(Object.assign({}, spec), { requestMethod: req.method, protocolName, timeoutMs: timeout.timeoutMs, shutdownSignal: opt.shutdownSignal, requestSignal: req.signal, requestHeader: req.header, url: req.url, responseHeader: {
-                [headerContentType]: type.binary
-                    ? contentTypeStreamProto
-                    : contentTypeStreamJson,
-            }, contextValues: req.contextValues }));
-        const compression = compressionNegotiate(opt.acceptCompression, req.header.get(headerStreamEncoding), req.header.get(headerStreamAcceptEncoding), headerStreamAcceptEncoding);
-        if (compression.response) {
-            context.responseHeader.set(headerStreamEncoding, compression.response.name);
-        }
-        // We split the pipeline into two parts: The request iterator, and the
-        // response iterator. We do this because the request iterator is responsible
-        // for parsing the request body, and we don't want write errors of the response
-        // iterator to affect the request iterator.
-        const inputIt = pipe(req.body, transformPrepend(() => {
-            if (opt.requireConnectProtocolHeader) {
-                requireProtocolVersionHeader(req.header);
-            }
-            // raise compression error to serialize it as the end stream response
-            if (compression.error)
-                throw compression.error;
-            // raise timeout parsing error to serialize it as a trailer status
-            if (timeout.error)
-                throw timeout.error;
-            return undefined;
-        }), transformSplitEnvelope(opt.readMaxBytes), transformDecompressEnvelope(compression.request, opt.readMaxBytes), transformParseEnvelope(serialization.getI(type.binary), endStreamFlag));
-        const it = transformInvokeImplementation(spec, context, opt.interceptors)(inputIt)[Symbol.asyncIterator]();
-        const outputIt = pipe(
-        // We wrap the iterator in an async iterator to ensure that the
-        // abort signal is aborted when the iterator is done.
-        {
-            [Symbol.asyncIterator]() {
-                return {
-                    next: () => it.next(),
-                    throw: (e) => {
-                        var _a, _b;
-                        context.abort(e);
-                        return (_b = (_a = it.throw) === null || _a === void 0 ? void 0 : _a.call(it, e)) !== null && _b !== void 0 ? _b : Promise.reject({ done: true });
-                    },
-                    return: (v) => {
-                        var _a, _b;
-                        context.abort();
-                        return ((_b = (_a = it.return) === null || _a === void 0 ? void 0 : _a.call(it, v)) !== null && _b !== void 0 ? _b : Promise.resolve({ done: true, value: v }));
-                    },
-                };
-            },
-        }, transformSerializeEnvelope(serialization.getO(type.binary)), transformCatchFinally((e) => {
-            context.abort();
-            const end = {
-                metadata: context.responseTrailer,
-            };
-            if (e instanceof ConnectError) {
-                end.error = e;
-            }
-            else if (e !== undefined) {
-                end.error = new ConnectError("internal error", Code.Internal, undefined, undefined, e);
-            }
-            return {
-                flags: endStreamFlag,
-                data: endStreamSerialization.serialize(end),
-            };
-        }), transformCompressEnvelope(compression.response, opt.compressMinBytes), transformJoinEnvelopes(), { propagateDownStreamError: true });
-        return Object.assign(Object.assign({}, uResponseOk), { 
-            // We wait for the first response body bytes before resolving, so that
-            // implementations have a chance to add headers before an adapter commits
-            // them to the wire.
-            body: await untilFirst(outputIt), header: context.responseHeader });
-    };
-}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/headers.d.ts

@@ -1,12 +0,0 @@
-/**
- * @private Internal code, does not follow semantic versioning.
- */
-export declare const headerContentType = "Content-Type";
-export declare const headerUnaryContentLength = "Content-Length";
-export declare const headerUnaryEncoding = "Content-Encoding";
-export declare const headerStreamEncoding = "Connect-Content-Encoding";
-export declare const headerUnaryAcceptEncoding = "Accept-Encoding";
-export declare const headerStreamAcceptEncoding = "Connect-Accept-Encoding";
-export declare const headerTimeout = "Connect-Timeout-Ms";
-export declare const headerProtocolVersion = "Connect-Protocol-Version";
-export declare const headerUserAgent = "User-Agent";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/headers.js

@@ -1,25 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-/**
- * @private Internal code, does not follow semantic versioning.
- */
-export const headerContentType = "Content-Type";
-export const headerUnaryContentLength = "Content-Length";
-export const headerUnaryEncoding = "Content-Encoding";
-export const headerStreamEncoding = "Connect-Content-Encoding";
-export const headerUnaryAcceptEncoding = "Accept-Encoding";
-export const headerStreamAcceptEncoding = "Connect-Accept-Encoding";
-export const headerTimeout = "Connect-Timeout-Ms";
-export const headerProtocolVersion = "Connect-Protocol-Version";
-export const headerUserAgent = "User-Agent";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/http-status.d.ts

@@ -1,15 +0,0 @@
-import { Code } from "../code.js";
-/**
- * Determine the Connect error code for the given HTTP status code.
- * See https://connectrpc.com/docs/protocol/#http-to-error-code
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function codeFromHttpStatus(httpStatus: number): Code;
-/**
- * Returns a HTTP status code for the given Connect code.
- * See https://connectrpc.com/docs/protocol#error-codes
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function codeToHttpStatus(code: Code): number;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/http-status.js

@@ -1,86 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Code } from "../code.js";
-/**
- * Determine the Connect error code for the given HTTP status code.
- * See https://connectrpc.com/docs/protocol/#http-to-error-code
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function codeFromHttpStatus(httpStatus) {
-    switch (httpStatus) {
-        case 400: // Bad Request
-            return Code.Internal;
-        case 401: // Unauthorized
-            return Code.Unauthenticated;
-        case 403: // Forbidden
-            return Code.PermissionDenied;
-        case 404: // Not Found
-            return Code.Unimplemented;
-        case 429: // Too Many Requests
-            return Code.Unavailable;
-        case 502: // Bad Gateway
-            return Code.Unavailable;
-        case 503: // Service Unavailable
-            return Code.Unavailable;
-        case 504: // Gateway Timeout
-            return Code.Unavailable;
-        default:
-            return Code.Unknown;
-    }
-}
-/**
- * Returns a HTTP status code for the given Connect code.
- * See https://connectrpc.com/docs/protocol#error-codes
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function codeToHttpStatus(code) {
-    switch (code) {
-        case Code.Canceled:
-            return 499; // Client Closed Request
-        case Code.Unknown:
-            return 500; // Internal Server Error
-        case Code.InvalidArgument:
-            return 400; // Bad Request
-        case Code.DeadlineExceeded:
-            return 504; // Gateway Timeout
-        case Code.NotFound:
-            return 404; // Not Found
-        case Code.AlreadyExists:
-            return 409; // Conflict
-        case Code.PermissionDenied:
-            return 403; // Forbidden
-        case Code.ResourceExhausted:
-            return 429; // Too Many Requests
-        case Code.FailedPrecondition:
-            return 400; // Bad Request
-        case Code.Aborted:
-            return 409; // Conflict
-        case Code.OutOfRange:
-            return 400; // Bad Request
-        case Code.Unimplemented:
-            return 501; // Not Implemented
-        case Code.Internal:
-            return 500; // Internal Server Error
-        case Code.Unavailable:
-            return 503; // Service Unavailable
-        case Code.DataLoss:
-            return 500; // Internal Server Error
-        case Code.Unauthenticated:
-            return 401; // Unauthorized
-        default:
-            return 500; // same as CodeUnknown
-    }
-}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/index.d.ts

@@ -1,16 +0,0 @@
-export { createHandlerFactory } from "./handler-factory.js";
-export { createTransport } from "./transport.js";
-export { codeFromHttpStatus, codeToHttpStatus } from "./http-status.js";
-export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
-export { endStreamToJson, endStreamFromJson, endStreamFlag, createEndStreamSerialization, } from "./end-stream.js";
-export type { EndStreamResponse } from "./end-stream.js";
-export { errorFromJson, errorFromJsonBytes, errorToJson, errorToJsonBytes, } from "./error-json.js";
-export { parseContentType, contentTypeUnaryProto, contentTypeUnaryJson, contentTypeStreamProto, contentTypeStreamJson, contentTypeRegExp, contentTypeUnaryRegExp, contentTypeStreamRegExp, } from "./content-type.js";
-export { parseTimeout } from "./parse-timeout.js";
-export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
-export { trailerMux, trailerDemux } from "./trailer-mux.js";
-export * from "./headers.js";
-export { transformConnectPostToGetRequest } from "./get-request.js";
-export { protocolVersion } from "./version.js";
-export { codeFromString } from "./code-string.js";
-export { codeToString } from "./code-string.js";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/index.js

@@ -1,33 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-export { createHandlerFactory } from "./handler-factory.js";
-export { createTransport } from "./transport.js";
-// All exports below are private — internal code that does not follow semantic
-// versioning.
-// We will try hard to avoid breaking changes, but if you depend on the
-// following exports, we recommend that you do so with an exact version
-// constraint (no ~ or ^).
-export { codeFromHttpStatus, codeToHttpStatus } from "./http-status.js";
-export { requestHeader, requestHeaderWithCompression, } from "./request-header.js";
-export { endStreamToJson, endStreamFromJson, endStreamFlag, createEndStreamSerialization, } from "./end-stream.js";
-export { errorFromJson, errorFromJsonBytes, errorToJson, errorToJsonBytes, } from "./error-json.js";
-export { parseContentType, contentTypeUnaryProto, contentTypeUnaryJson, contentTypeStreamProto, contentTypeStreamJson, contentTypeRegExp, contentTypeUnaryRegExp, contentTypeStreamRegExp, } from "./content-type.js";
-export { parseTimeout } from "./parse-timeout.js";
-export { validateResponse, validateResponseWithCompression, } from "./validate-response.js";
-export { trailerMux, trailerDemux } from "./trailer-mux.js";
-export * from "./headers.js";
-export { transformConnectPostToGetRequest } from "./get-request.js";
-export { protocolVersion } from "./version.js";
-export { codeFromString } from "./code-string.js";
-export { codeToString } from "./code-string.js";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/parse-timeout.d.ts

@@ -1,13 +0,0 @@
-import { ConnectError } from "../connect-error.js";
-/**
- * Parse a Connect Timeout (Deadline) header.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function parseTimeout(value: string | null, maxTimeoutMs: number): {
-    timeoutMs?: number;
-    error?: undefined;
-} | {
-    timeoutMs?: number;
-    error: ConnectError;
-};

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/parse-timeout.js

@@ -1,41 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Code } from "../code.js";
-import { ConnectError } from "../connect-error.js";
-/**
- * Parse a Connect Timeout (Deadline) header.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function parseTimeout(value, maxTimeoutMs) {
-    if (value === null) {
-        return {};
-    }
-    const results = /^\d{1,10}$/.exec(value);
-    if (results === null) {
-        return {
-            error: new ConnectError(`protocol error: invalid connect timeout value: ${value}`, Code.InvalidArgument),
-        };
-    }
-    const timeoutMs = parseInt(results[0]);
-    if (timeoutMs > maxTimeoutMs) {
-        return {
-            timeoutMs: timeoutMs,
-            error: new ConnectError(`timeout ${timeoutMs}ms must be <= ${maxTimeoutMs}`, Code.InvalidArgument),
-        };
-    }
-    return {
-        timeoutMs: parseInt(results[0]),
-    };
-}

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/query-params.d.ts

@@ -1,8 +0,0 @@
-/**
- * @private Internal code, does not follow semantic versioning.
- */
-export declare const paramConnectVersion = "connect";
-export declare const paramEncoding = "encoding";
-export declare const paramCompression = "compression";
-export declare const paramBase64 = "base64";
-export declare const paramMessage = "message";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/query-params.js

@@ -1,21 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-/**
- * @private Internal code, does not follow semantic versioning.
- */
-export const paramConnectVersion = "connect";
-export const paramEncoding = "encoding";
-export const paramCompression = "compression";
-export const paramBase64 = "base64";
-export const paramMessage = "message";

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/request-header.d.ts

@@ -1,19 +0,0 @@
-import { MethodKind } from "@bufbuild/protobuf";
-import type { Compression } from "../protocol/compression.js";
-/**
- * Creates headers for a Connect request.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function requestHeader(methodKind: MethodKind, useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, setUserAgent: boolean): Headers;
-/**
- * Creates headers for a Connect request with compression.
- *
- * Note that we always set the Content-Encoding header for unary methods.
- * It is up to the caller to decide whether to apply compression - and remove
- * the header if compression is not used, for example because the payload is
- * too small to make compression effective.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export declare function requestHeaderWithCompression(methodKind: MethodKind, useBinaryFormat: boolean, timeoutMs: number | undefined, userProvidedHeaders: HeadersInit | undefined, acceptCompression: Compression[], sendCompression: Compression | null, setUserAgent: boolean): Headers;

package/node_modules/@connectrpc/connect/dist/esm/protocol-connect/request-header.js

@@ -1,66 +0,0 @@
-// Copyright 2021-2024 The Connect Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { MethodKind } from "@bufbuild/protobuf";
-import { headerContentType, headerStreamAcceptEncoding, headerStreamEncoding, headerUnaryAcceptEncoding, headerUnaryEncoding, headerTimeout, headerProtocolVersion, headerUserAgent, } from "./headers.js";
-import { protocolVersion } from "./version.js";
-import { contentTypeStreamJson, contentTypeStreamProto, contentTypeUnaryJson, contentTypeUnaryProto, } from "./content-type.js";
-/**
- * Creates headers for a Connect request.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent) {
-    const result = new Headers(userProvidedHeaders !== null && userProvidedHeaders !== void 0 ? userProvidedHeaders : {});
-    if (timeoutMs !== undefined) {
-        result.set(headerTimeout, `${timeoutMs}`);
-    }
-    result.set(headerContentType, methodKind == MethodKind.Unary
-        ? useBinaryFormat
-            ? contentTypeUnaryProto
-            : contentTypeUnaryJson
-        : useBinaryFormat
-            ? contentTypeStreamProto
-            : contentTypeStreamJson);
-    result.set(headerProtocolVersion, protocolVersion);
-    if (setUserAgent && !result.has(headerUserAgent)) {
-        result.set(headerUserAgent, "connect-es/1.7.0");
-    }
-    return result;
-}
-/**
- * Creates headers for a Connect request with compression.
- *
- * Note that we always set the Content-Encoding header for unary methods.
- * It is up to the caller to decide whether to apply compression - and remove
- * the header if compression is not used, for example because the payload is
- * too small to make compression effective.
- *
- * @private Internal code, does not follow semantic versioning.
- */
-export function requestHeaderWithCompression(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, acceptCompression, sendCompression, setUserAgent) {
-    const result = requestHeader(methodKind, useBinaryFormat, timeoutMs, userProvidedHeaders, setUserAgent);
-    if (sendCompression != null) {
-        const name = methodKind == MethodKind.Unary
-            ? headerUnaryEncoding
-            : headerStreamEncoding;
-        result.set(name, sendCompression.name);
-    }
-    if (acceptCompression.length > 0) {
-        const name = methodKind == MethodKind.Unary
-            ? headerUnaryAcceptEncoding
-            : headerStreamAcceptEncoding;
-        result.set(name, acceptCompression.map((c) => c.name).join(","));
-    }
-    return result;
-}