pi-cursor-sdk 0.1.11 → 0.1.12

package/node_modules/@connectrpc/connect/dist/esm/any-client.js

@@ -0,0 +1,31 @@
+// 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.
+/**
+ * Create any client for the given service.
+ *
+ * The given createMethod function is called for each method definition
+ * of the service. The function it returns is added to the client object
+ * as a method.
+ */
+export function makeAnyClient(service, createMethod) {
+    const client = {};
+    for (const [localName, methodInfo] of Object.entries(service.methods)) {
+        const method = createMethod(Object.assign(Object.assign({}, methodInfo), { localName,
+            service }));
+        if (method != null) {
+            client[localName] = method;
+        }
+    }
+    return client;
+}

package/node_modules/@connectrpc/connect/dist/esm/call-options.d.ts

@@ -0,0 +1,34 @@
+import type { ContextValues } from "./context-values.js";
+/**
+ * Options for a call. Every client should accept CallOptions as optional
+ * argument in its RPC methods.
+ */
+export interface CallOptions {
+    /**
+     * Timeout in milliseconds.
+     *
+     * Set to <= 0 to disable the default timeout.
+     */
+    timeoutMs?: number;
+    /**
+     * Custom headers to send with the request.
+     */
+    headers?: HeadersInit;
+    /**
+     * An optional AbortSignal to cancel the call.
+     * If cancelled, an error with Code.Canceled is raised.
+     */
+    signal?: AbortSignal;
+    /**
+     * Called when response headers are received.
+     */
+    onHeader?(headers: Headers): void;
+    /**
+     * Called when response trailers are received.
+     */
+    onTrailer?(trailers: Headers): void;
+    /**
+     * ContextValues to pass to the interceptors.
+     */
+    contextValues?: ContextValues;
+}

package/node_modules/@connectrpc/connect/dist/esm/call-options.js

@@ -0,0 +1,14 @@
+// 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 {};

package/node_modules/@connectrpc/connect/dist/esm/callback-client.d.ts

@@ -0,0 +1,31 @@
+import type { MethodInfoServerStreaming, MethodInfoUnary, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import { ConnectError } from "./connect-error.js";
+import type { Transport } from "./transport.js";
+import type { CallOptions } from "./call-options.js";
+/**
+ * CallbackClient is a simple client that supports unary and server
+ * streaming methods. Methods take callback functions, which will be
+ * called when a response message arrives, or an error occurs.
+ *
+ * Client methods return a function that cancels the call. This is a
+ * convenient alternative to creating a AbortController and passing
+ * its AbortSignal as an option to the method.
+ *
+ * If a call is cancelled by an AbortController or by the returned
+ * cancel-function, ConnectErrors with the code Canceled are
+ * silently discarded.
+ *
+ * CallbackClient is most convenient for use in React effects, where
+ * a function returned by the effect is called when the effect is
+ * torn down.
+ */
+export type CallbackClient<T extends ServiceType> = {
+    [P in keyof T["methods"]]: T["methods"][P] extends MethodInfoUnary<infer I, infer O> ? (request: PartialMessage<I>, callback: (error: ConnectError | undefined, response: O) => void, options?: CallOptions) => CancelFn : T["methods"][P] extends MethodInfoServerStreaming<infer I, infer O> ? (request: PartialMessage<I>, messageCallback: (response: O) => void, closeCallback: (error: ConnectError | undefined) => void, options?: CallOptions) => CancelFn : never;
+};
+type CancelFn = () => void;
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+export declare function createCallbackClient<T extends ServiceType>(service: T, transport: Transport): CallbackClient<T>;
+export {};

package/node_modules/@connectrpc/connect/dist/esm/callback-client.js

@@ -0,0 +1,113 @@
+// 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.
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { Message, MethodKind } from "@bufbuild/protobuf";
+import { ConnectError } from "./connect-error.js";
+import { Code } from "./code.js";
+import { makeAnyClient } from "./any-client.js";
+import { createAsyncIterable } from "./protocol/async-iterable.js";
+/**
+ * Create a CallbackClient for the given service, invoking RPCs through the
+ * given transport.
+ */
+export function createCallbackClient(service, transport) {
+    return makeAnyClient(service, (method) => {
+        switch (method.kind) {
+            case MethodKind.Unary:
+                return createUnaryFn(transport, service, method);
+            case MethodKind.ServerStreaming:
+                return createServerStreamingFn(transport, service, method);
+            default:
+                return null;
+        }
+    });
+}
+function createUnaryFn(transport, service, method) {
+    return function (requestMessage, callback, options) {
+        const abort = new AbortController();
+        options = wrapSignal(abort, options);
+        transport
+            .unary(service, method, abort.signal, options.timeoutMs, options.headers, requestMessage, options.contextValues)
+            .then((response) => {
+            var _a, _b;
+            (_a = options.onHeader) === null || _a === void 0 ? void 0 : _a.call(options, response.header);
+            (_b = options.onTrailer) === null || _b === void 0 ? void 0 : _b.call(options, response.trailer);
+            callback(undefined, response.message);
+        }, (reason) => {
+            const err = ConnectError.from(reason, Code.Internal);
+            if (err.code === Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user.
+                return;
+            }
+            callback(err, new method.O());
+        });
+        return () => abort.abort();
+    };
+}
+function createServerStreamingFn(transport, service, method) {
+    return function (input, onResponse, onClose, options) {
+        const abort = new AbortController();
+        async function run() {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            options = wrapSignal(abort, options);
+            const response = await transport.stream(service, method, options.signal, options.timeoutMs, options.headers, createAsyncIterable([input]), options.contextValues);
+            (_d = options.onHeader) === null || _d === void 0 ? void 0 : _d.call(options, response.header);
+            try {
+                for (var _f = true, _g = __asyncValues(response.message), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const message = _c;
+                    onResponse(message);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            (_e = options.onTrailer) === null || _e === void 0 ? void 0 : _e.call(options, response.trailer);
+            onClose(undefined);
+        }
+        run().catch((reason) => {
+            const err = ConnectError.from(reason, Code.Internal);
+            if (err.code === Code.Canceled && abort.signal.aborted) {
+                // As documented, discard Canceled errors if canceled by the user,
+                // but do invoke the close-callback.
+                onClose(undefined);
+            }
+            else {
+                onClose(err);
+            }
+        });
+        return () => abort.abort();
+    };
+}
+function wrapSignal(abort, options) {
+    if (options === null || options === void 0 ? void 0 : options.signal) {
+        options.signal.addEventListener("abort", () => abort.abort());
+        if (options.signal.aborted) {
+            abort.abort();
+        }
+    }
+    return Object.assign(Object.assign({}, options), { signal: abort.signal });
+}

package/node_modules/@connectrpc/connect/dist/esm/code.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Connect represents categories of errors as codes, and each code maps to a
+ * specific HTTP status code. The codes and their semantics were chosen to
+ * match gRPC. Only the codes below are valid — there are no user-defined
+ * codes.
+ *
+ * See the specification at https://connectrpc.com/docs/protocol#error-codes
+ * for details.
+ */
+export declare enum Code {
+    /**
+     * Canceled, usually be the user
+     */
+    Canceled = 1,
+    /**
+     * Unknown error
+     */
+    Unknown = 2,
+    /**
+     * Argument invalid regardless of system state
+     */
+    InvalidArgument = 3,
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    DeadlineExceeded = 4,
+    /**
+     * Entity not found.
+     */
+    NotFound = 5,
+    /**
+     * Entity already exists.
+     */
+    AlreadyExists = 6,
+    /**
+     * Operation not authorized.
+     */
+    PermissionDenied = 7,
+    /**
+     * Quota exhausted.
+     */
+    ResourceExhausted = 8,
+    /**
+     * Argument invalid in current system state.
+     */
+    FailedPrecondition = 9,
+    /**
+     * Operation aborted.
+     */
+    Aborted = 10,
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    OutOfRange = 11,
+    /**
+     * Operation not implemented or disabled.
+     */
+    Unimplemented = 12,
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Internal = 13,
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Unavailable = 14,
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    DataLoss = 15,
+    /**
+     * Request isn't authenticated.
+     */
+    Unauthenticated = 16
+}

package/node_modules/@connectrpc/connect/dist/esm/code.js

@@ -0,0 +1,89 @@
+// 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.
+/**
+ * Connect represents categories of errors as codes, and each code maps to a
+ * specific HTTP status code. The codes and their semantics were chosen to
+ * match gRPC. Only the codes below are valid — there are no user-defined
+ * codes.
+ *
+ * See the specification at https://connectrpc.com/docs/protocol#error-codes
+ * for details.
+ */
+export var Code;
+(function (Code) {
+    /**
+     * Canceled, usually be the user
+     */
+    Code[Code["Canceled"] = 1] = "Canceled";
+    /**
+     * Unknown error
+     */
+    Code[Code["Unknown"] = 2] = "Unknown";
+    /**
+     * Argument invalid regardless of system state
+     */
+    Code[Code["InvalidArgument"] = 3] = "InvalidArgument";
+    /**
+     * Operation expired, may or may not have completed.
+     */
+    Code[Code["DeadlineExceeded"] = 4] = "DeadlineExceeded";
+    /**
+     * Entity not found.
+     */
+    Code[Code["NotFound"] = 5] = "NotFound";
+    /**
+     * Entity already exists.
+     */
+    Code[Code["AlreadyExists"] = 6] = "AlreadyExists";
+    /**
+     * Operation not authorized.
+     */
+    Code[Code["PermissionDenied"] = 7] = "PermissionDenied";
+    /**
+     * Quota exhausted.
+     */
+    Code[Code["ResourceExhausted"] = 8] = "ResourceExhausted";
+    /**
+     * Argument invalid in current system state.
+     */
+    Code[Code["FailedPrecondition"] = 9] = "FailedPrecondition";
+    /**
+     * Operation aborted.
+     */
+    Code[Code["Aborted"] = 10] = "Aborted";
+    /**
+     * Out of bounds, use instead of FailedPrecondition.
+     */
+    Code[Code["OutOfRange"] = 11] = "OutOfRange";
+    /**
+     * Operation not implemented or disabled.
+     */
+    Code[Code["Unimplemented"] = 12] = "Unimplemented";
+    /**
+     * Internal error, reserved for "serious errors".
+     */
+    Code[Code["Internal"] = 13] = "Internal";
+    /**
+     * Unavailable, client should back off and retry.
+     */
+    Code[Code["Unavailable"] = 14] = "Unavailable";
+    /**
+     * Unrecoverable data loss or corruption.
+     */
+    Code[Code["DataLoss"] = 15] = "DataLoss";
+    /**
+     * Request isn't authenticated.
+     */
+    Code[Code["Unauthenticated"] = 16] = "Unauthenticated";
+})(Code || (Code = {}));

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

@@ -0,0 +1,90 @@
+import { Code } from "./code.js";
+import type { Message, AnyMessage, IMessageTypeRegistry, JsonValue, MessageType } from "@bufbuild/protobuf";
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+export declare class ConnectError extends Error {
+    /**
+     * The Code for this error.
+     */
+    readonly code: Code;
+    /**
+     * A union of response headers and trailers associated with this error.
+     */
+    readonly metadata: Headers;
+    /**
+     * When an error is parsed from the wire, incoming error details are stored
+     * in this property. They can be retrieved using findDetails().
+     *
+     * When an error is constructed to be sent over the wire, outgoing error
+     * details are stored in this property as well.
+     */
+    details: (Message | IncomingDetail)[];
+    /**
+     * The error message, but without a status code in front.
+     *
+     * For example, a new `ConnectError("hello", Code.NotFound)` will have
+     * the message `[not found] hello`, and the rawMessage `hello`.
+     */
+    readonly rawMessage: string;
+    name: string;
+    /**
+     * The underlying cause of this error, if any. In cases where the actual cause
+     * is elided with the error message, the cause is specified here so that we
+     * don't leak the underlying error, but instead make it available for logging.
+     */
+    cause: unknown;
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with error.
+     */
+    constructor(message: string, code?: Code, metadata?: HeadersInit, outgoingDetails?: Message[], cause?: unknown);
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError from the fetch API, return the message
+     *   of the AbortError with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason: unknown, code?: Code): ConnectError;
+    static [Symbol.hasInstance](v: unknown): boolean;
+    /**
+     * Retrieve error details from a ConnectError. On the wire, error details are
+     * wrapped with google.protobuf.Any, so that a server or middleware can attach
+     * arbitrary data to an error. This function decodes the array of error details
+     * from the ConnectError object, and returns an array with the decoded
+     * messages. Any decoding errors are ignored, and the detail will simply be
+     * omitted from the list.
+     */
+    findDetails<T extends Message<T>>(type: MessageType<T>): T[];
+    findDetails(registry: IMessageTypeRegistry): AnyMessage[];
+}
+/**
+ * An incoming detail is basically a google.protobuf.Any, but it includes an
+ * optional JSON representation in the "debug" key, and stores a type name
+ * instead of a type URL.
+ */
+type IncomingDetail = {
+    type: string;
+    value: Uint8Array;
+    debug?: JsonValue;
+};
+export {};

package/node_modules/@connectrpc/connect/dist/esm/connect-error.js

@@ -0,0 +1,130 @@
+// 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 { codeToString } from "./protocol-connect/code-string.js";
+/**
+ * ConnectError captures four pieces of information: a Code, an error
+ * message, an optional cause of the error, and an optional collection of
+ * arbitrary Protobuf messages called  "details".
+ *
+ * Because developer tools typically show just the error message, we prefix
+ * it with the status code, so that the most important information is always
+ * visible immediately.
+ *
+ * Error details are wrapped with google.protobuf.Any on the wire, so that
+ * a server or middleware can attach arbitrary data to an error. Use the
+ * method findDetails() to retrieve the details.
+ */
+export class ConnectError extends Error {
+    /**
+     * Create a new ConnectError.
+     * If no code is provided, code "unknown" is used.
+     * Outgoing details are only relevant for the server side - a service may
+     * raise an error with details, and it is up to the protocol implementation
+     * to encode and send the details along with error.
+     */
+    constructor(message, code = Code.Unknown, metadata, outgoingDetails, cause) {
+        super(createMessage(message, code));
+        this.name = "ConnectError";
+        // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.rawMessage = message;
+        this.code = code;
+        this.metadata = new Headers(metadata !== null && metadata !== void 0 ? metadata : {});
+        this.details = outgoingDetails !== null && outgoingDetails !== void 0 ? outgoingDetails : [];
+        this.cause = cause;
+    }
+    /**
+     * Convert any value - typically a caught error into a ConnectError,
+     * following these rules:
+     * - If the value is already a ConnectError, return it as is.
+     * - If the value is an AbortError from the fetch API, return the message
+     *   of the AbortError with code Canceled.
+     * - For other Errors, return the error message with code Unknown by default.
+     * - For other values, return the values String representation as a message,
+     *   with the code Unknown by default.
+     * The original value will be used for the "cause" property for the new
+     * ConnectError.
+     */
+    static from(reason, code = Code.Unknown) {
+        if (reason instanceof ConnectError) {
+            return reason;
+        }
+        if (reason instanceof Error) {
+            if (reason.name == "AbortError") {
+                // Fetch requests can only be canceled with an AbortController.
+                // We detect that condition by looking at the name of the raised
+                // error object, and translate to the appropriate status code.
+                return new ConnectError(reason.message, Code.Canceled);
+            }
+            return new ConnectError(reason.message, code, undefined, undefined, reason);
+        }
+        return new ConnectError(String(reason), code, undefined, undefined, reason);
+    }
+    static [Symbol.hasInstance](v) {
+        if (!(v instanceof Error)) {
+            return false;
+        }
+        if (Object.getPrototypeOf(v) === ConnectError.prototype) {
+            return true;
+        }
+        return (v.name === "ConnectError" &&
+            "code" in v &&
+            typeof v.code === "number" &&
+            "metadata" in v &&
+            "details" in v &&
+            Array.isArray(v.details) &&
+            "rawMessage" in v &&
+            typeof v.rawMessage == "string" &&
+            "cause" in v);
+    }
+    findDetails(typeOrRegistry) {
+        const registry = "typeName" in typeOrRegistry
+            ? {
+                findMessage: (typeName) => typeName === typeOrRegistry.typeName ? typeOrRegistry : undefined,
+            }
+            : typeOrRegistry;
+        const details = [];
+        for (const data of this.details) {
+            if ("getType" in data) {
+                if (registry.findMessage(data.getType().typeName)) {
+                    details.push(data);
+                }
+                continue;
+            }
+            const type = registry.findMessage(data.type);
+            if (type) {
+                try {
+                    details.push(type.fromBinary(data.value));
+                }
+                catch (_) {
+                    // We silently give up if we are unable to parse the detail, because
+                    // that appears to be the least worst behavior.
+                    // It is very unlikely that a user surrounds a catch body handling the
+                    // error with another try-catch statement, and we do not want to
+                    // recommend doing so.
+                }
+            }
+        }
+        return details;
+    }
+}
+/**
+ * Create an error message, prefixing the given code.
+ */
+function createMessage(message, code) {
+    return message.length
+        ? `[${codeToString(code)}] ${message}`
+        : `[${codeToString(code)}]`;
+}

package/node_modules/@connectrpc/connect/dist/esm/context-values.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ContextValues is a collection of context values.
+ */
+export interface ContextValues {
+    /**
+     * get returns a context value.
+     */
+    get<T>(key: ContextKey<T>): T;
+    /**
+     * set sets a context value. It returns the ContextValues to allow chaining.
+     */
+    set<T>(key: ContextKey<T>, value: T): this;
+    /**
+     * delete deletes a context value. It returns the ContextValues to allow chaining.
+     */
+    delete(key: ContextKey<unknown>): this;
+}
+/**
+ * createContextValues creates a new ContextValues.
+ */
+export declare function createContextValues(): ContextValues;
+/**
+ * ContextKey is a unique identifier for a context value.
+ */
+export type ContextKey<T> = {
+    id: symbol;
+    defaultValue: T;
+};
+/**
+ * createContextKey creates a new ContextKey.
+ */
+export declare function createContextKey<T>(defaultValue: T, options?: {
+    description?: string;
+}): ContextKey<T>;