feat: méthode WebSocket HA pour Lovelace + vue lumières créée

2026-02-22 18:28:34 +00:00
parent 7d6605e33e
commit 917d1da7c0
668 changed files with 198094 additions and 0 deletions
@@ -0,0 +1,94 @@
+# @improbable-eng/grpc-web
+> Library for making gRPC-Web requests from a browser
+
+This library is intended for both JavaScript and TypeScript usage from a web browser or NodeJS (see [Usage with NodeJS](#usage-with-nodejs)).
+
+*Note: This only works if the server supports [gRPC-Web](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md)*
+
+A Golang gRPC-Web middleware and a Golang-based gRPC-Web proxy are [available here](https://github.com/improbable-eng/grpc-web).
+
+Please see the full [gRPC-Web README](https://github.com/improbable-eng/grpc-web) for known limitations.
+
+## Installation
+
+`@improbable-eng/grpc-web` has peer dependencies of `google-protobuf` and `@types/google-protobuf`.
+
+`npm install google-protobuf @types/google-protobuf @improbable-eng/grpc-web --save`
+
+## Example Project
+
+There is an [example project available here](https://github.com/improbable-eng/grpc-web/tree/master/client/grpc-web-react-example)
+
+## Usage Overview
+* Use [`ts-protoc-gen`](https://www.npmjs.com/package/ts-protoc-gen) with [`protoc`](https://github.com/google/protobuf) to generate `.js` and `.d.ts` files for your request and response classes. `ts-protoc-gen` can also generate gRPC service definitions with the `service=true` argument.
+  * [Go to code generation docs](docs/code-generation.md)
+* Make a request using [`unary()`](docs/unary.md), [`invoke()`](docs/invoke.md) or [`client()`](docs/client.md)
+
+```javascript
+import {grpc} from "@improbable-eng/grpc-web";
+
+// Import code-generated data structures.
+import {BookService} from "./generated/proto/examplecom/library/book_service_pb_service";
+import {GetBookRequest} from "./generated/proto/examplecom/library/book_service_pb";
+
+const getBookRequest = new GetBookRequest();
+getBookRequest.setIsbn(60929871);
+grpc.unary(BookService.GetBook, {
+  request: getBookRequest,
+  host: host,
+  onEnd: res => {
+    const { status, statusMessage, headers, message, trailers } = res;
+    if (status === grpc.Code.OK && message) {
+      console.log("all ok. got book: ", message.toObject());
+    }
+  }
+});
+```
+
+* Requests can be aborted/cancelled before they complete:
+
+```javascript
+const request = grpc.unary(BookService.GetBook, { ... });
+request.cancel();
+```
+
+## Available Request Functions
+
+There are three functions for making gRPC requests:
+
+### [`grpc.unary`](docs/unary.md)
+This is a convenience function for making requests that consist of a single request message and single response message. It can only be used with unary methods.
+
+```protobuf
+rpc GetBook(GetBookRequest) returns (Book) {}
+```
+
+### [`grpc.invoke`](docs/invoke.md)
+This is a convenience function for making requests that consist of a single request message and a stream of response messages (server-streaming). It can also be used with unary methods.
+
+```protobuf
+rpc GetBook(GetBookRequest) returns (Book) {}
+rpc QueryBooks(QueryBooksRequest) returns (stream Book) {}
+```
+
+### [`grpc.client`](docs/client.md)
+`grpc.client` returns a client. Dependant upon [transport compatibility](docs/transport.md) this client is capable of sending multiple request messages (client-streaming) and receiving multiple response messages (server-streaming). It can be used with any type of method, but will enforce limiting the sending of messages for unary methods.
+
+```protobuf
+rpc GetBook(GetBookRequest) returns (Book) {}
+rpc QueryBooks(QueryBooksRequest) returns (stream Book) {}
+rpc LogReadPages(stream PageRead) returns (google.protobuf.Empty) {}
+rpc ListenForBooks(stream QueryBooksRequest) returns (stream Book) {}
+```
+
+## Usage with NodeJS
+Refer to [grpc-web-node-http-transport](https://www.npmjs.com/package/@improbable-eng/grpc-web-node-http-transport).
+
+## All Docs
+
+* [unary()](docs/unary.md)
+* [invoke()](docs/invoke.md)
+* [client()](docs/client.md)
+* [Code Generation](docs/code-generation.md)
+* [Concepts](docs/concepts.md)
+* [Transport](docs/transport.md)
@@ -0,0 +1,17 @@
+import { Metadata } from "./metadata";
+export declare function decodeASCII(input: Uint8Array): string;
+export declare function encodeASCII(input: string): Uint8Array;
+export declare enum ChunkType {
+    MESSAGE = 1,
+    TRAILERS = 2
+}
+export declare type Chunk = {
+    chunkType: ChunkType;
+    trailers?: Metadata;
+    data?: Uint8Array;
+};
+export declare class ChunkParser {
+    buffer: Uint8Array | null;
+    position: number;
+    parse(bytes: Uint8Array, flush?: boolean): Chunk[];
+}
@@ -0,0 +1,20 @@
+export declare enum Code {
+    OK = 0,
+    Canceled = 1,
+    Unknown = 2,
+    InvalidArgument = 3,
+    DeadlineExceeded = 4,
+    NotFound = 5,
+    AlreadyExists = 6,
+    PermissionDenied = 7,
+    ResourceExhausted = 8,
+    FailedPrecondition = 9,
+    Aborted = 10,
+    OutOfRange = 11,
+    Unimplemented = 12,
+    Internal = 13,
+    Unavailable = 14,
+    DataLoss = 15,
+    Unauthenticated = 16
+}
+export declare function httpStatusToCode(httpStatus: number): Code;
@@ -0,0 +1,22 @@
+import { Metadata } from "./metadata";
+import { Code } from "./Code";
+import { TransportFactory } from "./transports/Transport";
+import { MethodDefinition } from "./service";
+import { ProtobufMessage } from "./message";
+export interface RpcOptions {
+    transport?: TransportFactory;
+    debug?: boolean;
+}
+export interface ClientRpcOptions extends RpcOptions {
+    host: string;
+}
+export interface Client<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> {
+    start(metadata?: Metadata.ConstructorArg): void;
+    send(message: TRequest): void;
+    finishSend(): void;
+    close(): void;
+    onHeaders(callback: (headers: Metadata) => void): void;
+    onMessage(callback: (message: TResponse) => void): void;
+    onEnd(callback: (code: Code, message: string, trailers: Metadata) => void): void;
+}
+export declare function client<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage, M extends MethodDefinition<TRequest, TResponse>>(methodDescriptor: M, props: ClientRpcOptions): Client<TRequest, TResponse>;
@@ -0,0 +1 @@
+export declare function debug(...args: any[]): void;
@@ -0,0 +1 @@
+export default function detach(cb: () => void): void;
@@ -0,0 +1,60 @@
+import { BrowserHeaders } from "browser-headers";
+import * as impTransport from "./transports/Transport";
+import * as impTransportFetch from "./transports/http/fetch";
+import * as impTransportWebSocket from "./transports/websocket/websocket";
+import * as impTransportXhr from "./transports/http/xhr";
+import * as impTransportHttp from "./transports/http/http";
+import * as impCode from "./Code";
+import * as impInvoke from "./invoke";
+import * as impUnary from "./unary";
+import * as impClient from "./client";
+import * as impService from "./service";
+import * as impMessage from "./message";
+export declare namespace grpc {
+    interface ProtobufMessageClass<T extends ProtobufMessage> extends impMessage.ProtobufMessageClass<T> {
+    }
+    interface ProtobufMessage extends impMessage.ProtobufMessage {
+    }
+    interface Transport extends impTransport.Transport {
+    }
+    interface TransportOptions extends impTransport.TransportOptions {
+    }
+    interface TransportFactory extends impTransport.TransportFactory {
+    }
+    const setDefaultTransport: typeof impTransport.setDefaultTransportFactory;
+    const CrossBrowserHttpTransport: typeof impTransportHttp.CrossBrowserHttpTransport;
+    interface CrossBrowserHttpTransportInit extends impTransportHttp.CrossBrowserHttpTransportInit {
+    }
+    const FetchReadableStreamTransport: typeof impTransportFetch.FetchReadableStreamTransport;
+    interface FetchReadableStreamInit extends impTransportFetch.FetchTransportInit {
+    }
+    const XhrTransport: typeof impTransportXhr.XhrTransport;
+    interface XhrTransportInit extends impTransportXhr.XhrTransportInit {
+    }
+    const WebsocketTransport: typeof impTransportWebSocket.WebsocketTransport;
+    interface UnaryMethodDefinition<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends impService.UnaryMethodDefinition<TRequest, TResponse> {
+    }
+    interface MethodDefinition<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends impService.MethodDefinition<TRequest, TResponse> {
+    }
+    interface ServiceDefinition extends impService.ServiceDefinition {
+    }
+    export import Code = impCode.Code;
+    export import Metadata = BrowserHeaders;
+    interface Client<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends impClient.Client<TRequest, TResponse> {
+    }
+    function client<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage, M extends MethodDefinition<TRequest, TResponse>>(methodDescriptor: M, props: ClientRpcOptions): Client<TRequest, TResponse>;
+    interface RpcOptions extends impClient.RpcOptions {
+    }
+    interface ClientRpcOptions extends impClient.ClientRpcOptions {
+    }
+    const invoke: typeof impInvoke.invoke;
+    interface Request extends impInvoke.Request {
+    }
+    interface InvokeRpcOptions<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends impInvoke.InvokeRpcOptions<TRequest, TResponse> {
+    }
+    const unary: typeof impUnary.unary;
+    interface UnaryOutput<TResponse extends ProtobufMessage> extends impUnary.UnaryOutput<TResponse> {
+    }
+    interface UnaryRpcOptions<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends impUnary.UnaryRpcOptions<TRequest, TResponse> {
+    }
+}
@@ -0,0 +1,17 @@
+import { Code } from "./Code";
+import { MethodDefinition } from "./service";
+import { Metadata } from "./metadata";
+import { RpcOptions } from "./client";
+import { ProtobufMessage } from "./message";
+export interface Request {
+    close: () => void;
+}
+export interface InvokeRpcOptions<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends RpcOptions {
+    host: string;
+    request: TRequest;
+    metadata?: Metadata.ConstructorArg;
+    onHeaders?: (headers: Metadata) => void;
+    onMessage?: (res: TResponse) => void;
+    onEnd: (code: Code, message: string, trailers: Metadata) => void;
+}
+export declare function invoke<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage, M extends MethodDefinition<TRequest, TResponse>>(methodDescriptor: M, props: InvokeRpcOptions<TRequest, TResponse>): Request;
@@ -0,0 +1,8 @@
+export interface ProtobufMessageClass<T extends ProtobufMessage> {
+    new (): T;
+    deserializeBinary(bytes: Uint8Array): T;
+}
+export interface ProtobufMessage {
+    toObject(): {};
+    serializeBinary(): Uint8Array;
+}
@@ -0,0 +1,2 @@
+import { BrowserHeaders } from "browser-headers";
+export { BrowserHeaders as Metadata };
@@ -0,0 +1,16 @@
+import { ProtobufMessage, ProtobufMessageClass } from "./message";
+export interface ServiceDefinition {
+    serviceName: string;
+}
+export interface MethodDefinition<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> {
+    methodName: string;
+    service: ServiceDefinition;
+    requestStream: boolean;
+    responseStream: boolean;
+    requestType: ProtobufMessageClass<TRequest>;
+    responseType: ProtobufMessageClass<TResponse>;
+}
+export interface UnaryMethodDefinition<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends MethodDefinition<TRequest, TResponse> {
+    requestStream: false;
+    responseStream: false;
+}
@@ -0,0 +1,22 @@
+import { Metadata } from "../metadata";
+import { MethodDefinition } from "../service";
+import { ProtobufMessage } from "../message";
+export interface Transport {
+    sendMessage(msgBytes: Uint8Array): void;
+    finishSend(): void;
+    cancel(): void;
+    start(metadata: Metadata): void;
+}
+export declare function setDefaultTransportFactory(t: TransportFactory): void;
+export declare function makeDefaultTransport(options: TransportOptions): Transport;
+export interface TransportOptions {
+    methodDefinition: MethodDefinition<ProtobufMessage, ProtobufMessage>;
+    debug: boolean;
+    url: string;
+    onHeaders: (headers: Metadata, status: number) => void;
+    onChunk: (chunkBytes: Uint8Array, flush?: boolean) => void;
+    onEnd: (err?: Error) => void;
+}
+export interface TransportFactory {
+    (options: TransportOptions): Transport;
+}
@@ -0,0 +1,6 @@
+import { TransportFactory } from "../Transport";
+declare type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export declare type FetchTransportInit = Omit<RequestInit, "headers" | "method" | "body" | "signal">;
+export declare function FetchReadableStreamTransport(init: FetchTransportInit): TransportFactory;
+export declare function detectFetchSupport(): boolean;
+export {};
@@ -0,0 +1,5 @@
+import { TransportFactory } from "../Transport";
+export interface CrossBrowserHttpTransportInit {
+    withCredentials?: boolean;
+}
+export declare function CrossBrowserHttpTransport(init: CrossBrowserHttpTransportInit): TransportFactory;
@@ -0,0 +1,27 @@
+import { Metadata } from "../../metadata";
+import { Transport, TransportFactory, TransportOptions } from "../Transport";
+export interface XhrTransportInit {
+    withCredentials?: boolean;
+}
+export declare function XhrTransport(init: XhrTransportInit): TransportFactory;
+export declare class XHR implements Transport {
+    options: TransportOptions;
+    init: XhrTransportInit;
+    xhr: XMLHttpRequest;
+    metadata: Metadata;
+    index: 0;
+    constructor(transportOptions: TransportOptions, init: XhrTransportInit);
+    onProgressEvent(): void;
+    onLoadEvent(): void;
+    onStateChange(): void;
+    sendMessage(msgBytes: Uint8Array): void;
+    finishSend(): void;
+    start(metadata: Metadata): void;
+    protected configureXhr(): void;
+    cancel(): void;
+}
+export declare class MozChunkedArrayBufferXHR extends XHR {
+    protected configureXhr(): void;
+    onProgressEvent(): void;
+}
+export declare function stringToArrayBuffer(str: string): Uint8Array;
@@ -0,0 +1,3 @@
+export declare function xhrSupportsResponseType(type: string): boolean;
+export declare function detectMozXHRSupport(): boolean;
+export declare function detectXHROverrideMimeTypeSupport(): boolean;
@@ -0,0 +1,2 @@
+import { TransportFactory } from "../Transport";
+export declare function WebsocketTransport(): TransportFactory;
@@ -0,0 +1,20 @@
+import { Metadata } from "./metadata";
+import { Code } from "./Code";
+import { UnaryMethodDefinition } from "./service";
+import { Request } from "./invoke";
+import { RpcOptions } from "./client";
+import { ProtobufMessage } from "./message";
+export interface UnaryOutput<TResponse> {
+    status: Code;
+    statusMessage: string;
+    headers: Metadata;
+    message: TResponse | null;
+    trailers: Metadata;
+}
+export interface UnaryRpcOptions<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage> extends RpcOptions {
+    host: string;
+    request: TRequest;
+    metadata?: Metadata.ConstructorArg;
+    onEnd: (output: UnaryOutput<TResponse>) => void;
+}
+export declare function unary<TRequest extends ProtobufMessage, TResponse extends ProtobufMessage, M extends UnaryMethodDefinition<TRequest, TResponse>>(methodDescriptor: M, props: UnaryRpcOptions<TRequest, TResponse>): Request;
@@ -0,0 +1,2 @@
+import { ProtobufMessage } from "./message";
+export declare function frameRequest(request: ProtobufMessage): Uint8Array;
@@ -0,0 +1,47 @@
+{
+  "name": "@improbable-eng/grpc-web",
+  "version": "0.15.0",
+  "description": "gRPC-Web client for browsers (JS/TS)",
+  "main": "dist/grpc-web-client.js",
+  "browser": "dist/grpc-web-client.umd.js",
+  "types": "dist/typings/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "postbootstrap": "npm run lib:build",
+    "lib:build": "npm run clean && webpack"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Improbable",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "github.com/improbable-eng/grpc-web"
+  },
+  "keywords": [
+    "grpc",
+    "grpc-web",
+    "protobuf",
+    "typescript",
+    "ts"
+  ],
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "google-protobuf": "^3.14.0"
+  },
+  "dependencies": {
+    "browser-headers": "^0.4.1"
+  },
+  "devDependencies": {
+    "@types/google-protobuf": "^3.7.4",
+    "@types/node": "^14.14.22",
+    "google-protobuf": "^3.14.0",
+    "ts-loader": "^8.0.14",
+    "typescript": "4.1.3",
+    "webpack": "^5.19.0",
+    "webpack-cli": "^4.4.0"
+  }
+}
				`@@ -0,0 +1 @@`
				`export declare function debug(...args: any[]): void;`
				`@@ -0,0 +1 @@`
				`export default function detach(cb: () => void): void;`