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

node_modules/@improbable-eng/grpc-web/dist/typings/ChunkParser.d.ts

@@ -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[];
+}

node_modules/@improbable-eng/grpc-web/dist/typings/Code.d.ts

@@ -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;

node_modules/@improbable-eng/grpc-web/dist/typings/client.d.ts

@@ -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>;

node_modules/@improbable-eng/grpc-web/dist/typings/debug.d.ts

@@ -0,0 +1 @@
+export declare function debug(...args: any[]): void;

node_modules/@improbable-eng/grpc-web/dist/typings/detach.d.ts

@@ -0,0 +1 @@
+export default function detach(cb: () => void): void;

node_modules/@improbable-eng/grpc-web/dist/typings/index.d.ts

@@ -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> {
+    }
+}

node_modules/@improbable-eng/grpc-web/dist/typings/invoke.d.ts

@@ -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;

node_modules/@improbable-eng/grpc-web/dist/typings/message.d.ts

@@ -0,0 +1,8 @@
+export interface ProtobufMessageClass<T extends ProtobufMessage> {
+    new (): T;
+    deserializeBinary(bytes: Uint8Array): T;
+}
+export interface ProtobufMessage {
+    toObject(): {};
+    serializeBinary(): Uint8Array;
+}

node_modules/@improbable-eng/grpc-web/dist/typings/metadata.d.ts

@@ -0,0 +1,2 @@
+import { BrowserHeaders } from "browser-headers";
+export { BrowserHeaders as Metadata };

node_modules/@improbable-eng/grpc-web/dist/typings/service.d.ts

@@ -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;
+}

node_modules/@improbable-eng/grpc-web/dist/typings/transports/Transport.d.ts

@@ -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;
+}

node_modules/@improbable-eng/grpc-web/dist/typings/transports/http/fetch.d.ts

@@ -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 {};

node_modules/@improbable-eng/grpc-web/dist/typings/transports/http/http.d.ts

@@ -0,0 +1,5 @@
+import { TransportFactory } from "../Transport";
+export interface CrossBrowserHttpTransportInit {
+    withCredentials?: boolean;
+}
+export declare function CrossBrowserHttpTransport(init: CrossBrowserHttpTransportInit): TransportFactory;

node_modules/@improbable-eng/grpc-web/dist/typings/transports/http/xhr.d.ts

@@ -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;

node_modules/@improbable-eng/grpc-web/dist/typings/transports/http/xhrUtil.d.ts

@@ -0,0 +1,3 @@
+export declare function xhrSupportsResponseType(type: string): boolean;
+export declare function detectMozXHRSupport(): boolean;
+export declare function detectXHROverrideMimeTypeSupport(): boolean;

node_modules/@improbable-eng/grpc-web/dist/typings/transports/websocket/websocket.d.ts

@@ -0,0 +1,2 @@
+import { TransportFactory } from "../Transport";
+export declare function WebsocketTransport(): TransportFactory;

node_modules/@improbable-eng/grpc-web/dist/typings/unary.d.ts

@@ -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;

node_modules/@improbable-eng/grpc-web/dist/typings/util.d.ts

@@ -0,0 +1,2 @@
+import { ProtobufMessage } from "./message";
+export declare function frameRequest(request: ProtobufMessage): Uint8Array;