@univerjs/network 0.1.0-alpha.3

package/lib/es/index.js

@@ -0,0 +1,423 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Disposable, toDisposable, remove, DisposableCollection } from "@univerjs/core";
+import { of, firstValueFrom, Observable } from "rxjs";
+import { concatMap, share } from "rxjs/operators";
+import { createIdentifier } from "@wendellhu/redi";
+const ApplicationJSONType = "application/json";
+class HTTPHeaders {
+  constructor(headers) {
+    __publicField(this, "_headers", /* @__PURE__ */ new Map());
+    if (typeof headers === "string") {
+      headers.split("\n").forEach((header) => {
+        const [name, value] = header.split(":");
+        if (name && value) {
+          this._setHeader(name, value);
+        }
+      });
+    } else {
+      if (headers) {
+        Object.keys(headers).forEach(([name, value]) => {
+          this._setHeader(name, value);
+        });
+      }
+    }
+  }
+  forEach(callback) {
+    this._headers.forEach((v, key) => callback(key, v));
+  }
+  has(key) {
+    return !!this._headers.has(key.toLowerCase());
+  }
+  get(key) {
+    const k = key.toLowerCase();
+    return this._headers.has(k) ? this._headers.get(k) : null;
+  }
+  _setHeader(name, value) {
+    const lowerCase = name.toLowerCase();
+    if (this._headers.has(lowerCase)) {
+      this._headers.get(lowerCase).push(value.toString());
+    } else {
+      this._headers.set(lowerCase, [value.toString()]);
+    }
+  }
+}
+const IHTTPImplementation = createIdentifier("univer-pro.network.http-implementation");
+class HTTPParams {
+  constructor(params) {
+    this.params = params;
+  }
+  toString() {
+    if (!this.params) {
+      return "";
+    }
+    return Object.keys(this.params).map((key) => `${key}=${this.params[key]}`).join("&");
+  }
+}
+class HTTPRequest {
+  constructor(method, url, requestParams) {
+    this.method = method;
+    this.url = url;
+    this.requestParams = requestParams;
+  }
+  get headers() {
+    return this.requestParams.headers;
+  }
+  get withCredentials() {
+    return this.requestParams.withCredentials;
+  }
+  get responseType() {
+    return this.requestParams.responseType;
+  }
+  getUrlWithParams() {
+    var _a, _b;
+    const params = (_b = (_a = this.requestParams) == null ? void 0 : _a.params) == null ? void 0 : _b.toString();
+    if (!params) {
+      return this.url;
+    }
+    return `${this.url}${this.url.includes("?") ? "&" : "?"}${params}`;
+  }
+  getBody() {
+    var _a;
+    const contentType = this.headers.get("Content-Type") ?? ApplicationJSONType;
+    const body = (_a = this.requestParams) == null ? void 0 : _a.body;
+    if (contentType === ApplicationJSONType && body && typeof body === "object") {
+      return JSON.stringify(body);
+    }
+    return body ? `${body}` : null;
+  }
+}
+class HTTPResponse {
+  constructor({
+    body,
+    headers,
+    status,
+    statusText
+  }) {
+    __publicField(this, "body");
+    __publicField(this, "headers");
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    this.body = body;
+    this.headers = headers;
+    this.status = status;
+    this.statusText = statusText;
+  }
+}
+class HTTPResponseError {
+  constructor({
+    headers,
+    status,
+    statusText,
+    error
+  }) {
+    __publicField(this, "headers");
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    __publicField(this, "error");
+    this.headers = headers;
+    this.status = status;
+    this.statusText = statusText;
+    this.error = error;
+  }
+}
+class ResponseHeader {
+  constructor(headers, status, statusText) {
+    this.headers = headers;
+    this.status = status;
+    this.statusText = statusText;
+  }
+}
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp2(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+let HTTPService = class extends Disposable {
+  constructor(_http) {
+    super();
+    __publicField(this, "_interceptors", []);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __publicField(this, "_pipe");
+    this._http = _http;
+  }
+  registerHTTPInterceptor(interceptor) {
+    if (this._interceptors.indexOf(interceptor) !== -1) {
+      throw new Error("[HTTPService]: The interceptor has already been registered!");
+    }
+    this._interceptors.push(interceptor);
+    this._interceptors = this._interceptors.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    this._pipe = null;
+    return toDisposable(() => remove(this._interceptors, interceptor));
+  }
+  get(url, options) {
+    return this._request("GET", url, options);
+  }
+  post(url, options) {
+    return this._request("POST", url, options);
+  }
+  put(url, options) {
+    return this._request("PUT", url, options);
+  }
+  delete(url, options) {
+    return this._request("DELETE", url, options);
+  }
+  /** The HTTP request implementations */
+  async _request(method, url, options) {
+    const headers = new HTTPHeaders(options == null ? void 0 : options.headers);
+    const params = new HTTPParams(options == null ? void 0 : options.params);
+    const request = new HTTPRequest(method, url, {
+      headers,
+      params,
+      withCredentials: (options == null ? void 0 : options.withCredentials) ?? false,
+      // default value for withCredentials is false by MDN
+      responseType: (options == null ? void 0 : options.responseType) ?? "json",
+      body: options == null ? void 0 : options.body
+    });
+    const events$ = of(request).pipe(
+      concatMap((request2) => this._runInterceptorsAndImplementation(request2))
+    );
+    const result = await firstValueFrom(events$);
+    if (result instanceof HTTPResponse) {
+      return result;
+    }
+    throw new Error(`${result.error}`);
+  }
+  _runInterceptorsAndImplementation(request) {
+    if (!this._pipe) {
+      this._pipe = this._interceptors.map((handler) => handler.interceptor).reduceRight(
+        (nextHandlerFunction, interceptorFunction) => chainInterceptorFn(nextHandlerFunction, interceptorFunction),
+        (requestFromPrevInterceptor, finalHandler) => finalHandler(requestFromPrevInterceptor)
+      );
+    }
+    return this._pipe(
+      request,
+      (requestToNext) => this._http.send(requestToNext)
+      /* final handler */
+    );
+  }
+};
+HTTPService = __decorateClass([
+  __decorateParam(0, IHTTPImplementation)
+], HTTPService);
+function chainInterceptorFn(afterInterceptorChain, currentInterceptorFn) {
+  return (prevRequest, nextHandlerFn) => currentInterceptorFn(prevRequest, (nextRequest) => afterInterceptorChain(nextRequest, nextHandlerFn));
+}
+const SuccessStatusCodeLowerBound = 200;
+const ErrorStatusCodeLowerBound = 300;
+var HTTPStatusCode = /* @__PURE__ */ ((HTTPStatusCode2) => {
+  HTTPStatusCode2[HTTPStatusCode2["Continue"] = 100] = "Continue";
+  HTTPStatusCode2[HTTPStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+  HTTPStatusCode2[HTTPStatusCode2["Processing"] = 102] = "Processing";
+  HTTPStatusCode2[HTTPStatusCode2["EarlyHints"] = 103] = "EarlyHints";
+  HTTPStatusCode2[HTTPStatusCode2["Ok"] = 200] = "Ok";
+  HTTPStatusCode2[HTTPStatusCode2["Created"] = 201] = "Created";
+  HTTPStatusCode2[HTTPStatusCode2["Accepted"] = 202] = "Accepted";
+  HTTPStatusCode2[HTTPStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+  HTTPStatusCode2[HTTPStatusCode2["NoContent"] = 204] = "NoContent";
+  HTTPStatusCode2[HTTPStatusCode2["ResetContent"] = 205] = "ResetContent";
+  HTTPStatusCode2[HTTPStatusCode2["PartialContent"] = 206] = "PartialContent";
+  HTTPStatusCode2[HTTPStatusCode2["MultiStatus"] = 207] = "MultiStatus";
+  HTTPStatusCode2[HTTPStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
+  HTTPStatusCode2[HTTPStatusCode2["ImUsed"] = 226] = "ImUsed";
+  HTTPStatusCode2[HTTPStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
+  HTTPStatusCode2[HTTPStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
+  HTTPStatusCode2[HTTPStatusCode2["Found"] = 302] = "Found";
+  HTTPStatusCode2[HTTPStatusCode2["SeeOther"] = 303] = "SeeOther";
+  HTTPStatusCode2[HTTPStatusCode2["NotModified"] = 304] = "NotModified";
+  HTTPStatusCode2[HTTPStatusCode2["UseProxy"] = 305] = "UseProxy";
+  HTTPStatusCode2[HTTPStatusCode2["Unused"] = 306] = "Unused";
+  HTTPStatusCode2[HTTPStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HTTPStatusCode2[HTTPStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HTTPStatusCode2[HTTPStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HTTPStatusCode2[HTTPStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HTTPStatusCode2[HTTPStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
+  HTTPStatusCode2[HTTPStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HTTPStatusCode2[HTTPStatusCode2["NotFound"] = 404] = "NotFound";
+  HTTPStatusCode2[HTTPStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HTTPStatusCode2[HTTPStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
+  HTTPStatusCode2[HTTPStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+  HTTPStatusCode2[HTTPStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
+  HTTPStatusCode2[HTTPStatusCode2["Conflict"] = 409] = "Conflict";
+  HTTPStatusCode2[HTTPStatusCode2["Gone"] = 410] = "Gone";
+  HTTPStatusCode2[HTTPStatusCode2["LengthRequired"] = 411] = "LengthRequired";
+  HTTPStatusCode2[HTTPStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HTTPStatusCode2[HTTPStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HTTPStatusCode2[HTTPStatusCode2["UriTooLong"] = 414] = "UriTooLong";
+  HTTPStatusCode2[HTTPStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HTTPStatusCode2[HTTPStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HTTPStatusCode2[HTTPStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HTTPStatusCode2[HTTPStatusCode2["ImATeapot"] = 418] = "ImATeapot";
+  HTTPStatusCode2[HTTPStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HTTPStatusCode2[HTTPStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  HTTPStatusCode2[HTTPStatusCode2["Locked"] = 423] = "Locked";
+  HTTPStatusCode2[HTTPStatusCode2["FailedDependency"] = 424] = "FailedDependency";
+  HTTPStatusCode2[HTTPStatusCode2["TooEarly"] = 425] = "TooEarly";
+  HTTPStatusCode2[HTTPStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
+  HTTPStatusCode2[HTTPStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
+  HTTPStatusCode2[HTTPStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
+  HTTPStatusCode2[HTTPStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+  HTTPStatusCode2[HTTPStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+  HTTPStatusCode2[HTTPStatusCode2["InternalServerError"] = 500] = "InternalServerError";
+  HTTPStatusCode2[HTTPStatusCode2["NotImplemented"] = 501] = "NotImplemented";
+  HTTPStatusCode2[HTTPStatusCode2["BadGateway"] = 502] = "BadGateway";
+  HTTPStatusCode2[HTTPStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HTTPStatusCode2[HTTPStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HTTPStatusCode2[HTTPStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  HTTPStatusCode2[HTTPStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HTTPStatusCode2[HTTPStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HTTPStatusCode2[HTTPStatusCode2["LoopDetected"] = 508] = "LoopDetected";
+  HTTPStatusCode2[HTTPStatusCode2["NotExtended"] = 510] = "NotExtended";
+  HTTPStatusCode2[HTTPStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+  return HTTPStatusCode2;
+})(HTTPStatusCode || {});
+class XHRHTTPImplementation {
+  send(request) {
+    return new Observable((observer) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open(request.method, request.getUrlWithParams());
+      if (request.withCredentials) {
+        xhr.withCredentials = true;
+      }
+      request.headers.forEach((key, value) => xhr.setRequestHeader(key, value.join(",")));
+      if (!request.headers.has("Accept")) {
+        xhr.setRequestHeader("Accept", "application/json, text/plain, */*");
+      }
+      if (!request.headers.has("Content-Type")) {
+        xhr.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
+      }
+      const buildResponseHeader = () => {
+        const statusText = xhr.statusText || "OK";
+        const headers = new HTTPHeaders(xhr.getAllResponseHeaders());
+        return new ResponseHeader(headers, xhr.status, statusText);
+      };
+      const onLoadHandler = () => {
+        const { headers, statusText, status } = buildResponseHeader();
+        const { responseType } = request;
+        let body2 = null;
+        let error = null;
+        if (status !== HTTPStatusCode.NoContent) {
+          body2 = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
+        }
+        let success = status >= SuccessStatusCodeLowerBound && status < ErrorStatusCodeLowerBound;
+        if (responseType === "json" && typeof body2 === "string") {
+          const originalBody = body2;
+          try {
+            body2 = body2 ? JSON.parse(body2) : null;
+          } catch (e) {
+            success = false;
+            body2 = originalBody;
+            error = e;
+          }
+        }
+        if (success) {
+          observer.next(
+            new HTTPResponse({
+              body: body2,
+              headers,
+              status,
+              statusText
+            })
+          );
+        } else {
+          observer.next(
+            new HTTPResponseError({
+              error,
+              headers,
+              status,
+              statusText
+            })
+          );
+        }
+      };
+      const onErrorHandler = (error) => {
+        const res = new HTTPResponseError({
+          error,
+          status: xhr.status || 0,
+          statusText: xhr.statusText || "Unknown Error",
+          headers: buildResponseHeader().headers
+        });
+        observer.next(res);
+      };
+      xhr.addEventListener("load", onLoadHandler);
+      xhr.addEventListener("error", onErrorHandler);
+      xhr.addEventListener("abort", onErrorHandler);
+      xhr.addEventListener("timeout", onErrorHandler);
+      const body = request.getBody();
+      xhr.send(body);
+      return () => {
+        if (xhr.readyState !== xhr.DONE) {
+          xhr.abort();
+        }
+        xhr.removeEventListener("load", onLoadHandler);
+        xhr.removeEventListener("error", onErrorHandler);
+        xhr.removeEventListener("abort", onErrorHandler);
+        xhr.removeEventListener("timeout", onErrorHandler);
+      };
+    });
+  }
+}
+const ISocketService = createIdentifier("univer.socket");
+class WebSocketService extends Disposable {
+  createSocket(URL) {
+    try {
+      const connection = new WebSocket(URL);
+      const disposables = new DisposableCollection();
+      const webSocket = {
+        URL,
+        close: (code, reason) => {
+          connection.close(code, reason);
+          disposables.dispose();
+        },
+        send: (data) => {
+          connection.send(data);
+        },
+        open$: new Observable((subscriber) => {
+          const callback = (event) => subscriber.next(event);
+          connection.addEventListener("open", callback);
+          disposables.add(toDisposable(() => connection.removeEventListener("open", callback)));
+        }).pipe(share()),
+        close$: new Observable((subscriber) => {
+          const callback = (event) => subscriber.next(event);
+          connection.addEventListener("close", callback);
+          disposables.add(toDisposable(() => connection.removeEventListener("close", callback)));
+        }).pipe(share()),
+        error$: new Observable((subscriber) => {
+          const callback = (event) => subscriber.next(event);
+          connection.addEventListener("error", callback);
+          disposables.add(toDisposable(() => connection.removeEventListener("error", callback)));
+        }).pipe(share()),
+        message$: new Observable((subscriber) => {
+          const callback = (event) => subscriber.next(event);
+          connection.addEventListener("message", callback);
+          disposables.add(toDisposable(() => connection.removeEventListener("message", callback)));
+        }).pipe(share())
+      };
+      return webSocket;
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+}
+export {
+  HTTPHeaders,
+  HTTPRequest,
+  HTTPResponse,
+  HTTPService,
+  IHTTPImplementation,
+  ISocketService,
+  WebSocketService,
+  XHRHTTPImplementation
+};

package/lib/types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 { HTTPHeaders } from './services/http/headers';
+export { HTTPService } from './services/http/http.service';
+export { IHTTPImplementation } from './services/http/implementations/implementation';
+export { XHRHTTPImplementation } from './services/http/implementations/xhr';
+export { HTTPRequest } from './services/http/request';
+export { HTTPResponse } from './services/http/response';
+export { type ISocket, ISocketService, type SocketBodyType, WebSocketService, } from './services/web-socket/web-socket.service';

package/lib/types/services/http/headers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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.
+ */
+interface IHeadersConstructorProps {
+    [key: string]: string | number | boolean;
+}
+export declare const ApplicationJSONType = "application/json";
+/**
+ * It wraps headers of HTTP requests' and responses' headers.
+ */
+export declare class HTTPHeaders {
+    private readonly _headers;
+    constructor(headers?: IHeadersConstructorProps | string);
+    forEach(callback: (name: string, value: string[]) => void): void;
+    has(key: string): boolean;
+    get(key: string): string[] | null;
+    private _setHeader;
+}
+export {};

package/lib/types/services/http/http.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 type HTTPResponseType = 'arraybuffer' | 'blob' | 'json' | 'text';
+export declare const SuccessStatusCodeLowerBound = 200;
+export declare const ErrorStatusCodeLowerBound = 300;
+/**
+ * Http status codes.
+ *
+ * https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+ */
+export declare enum HTTPStatusCode {
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    EarlyHints = 103,
+    Ok = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    ImUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    Unused = 306,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    PayloadTooLarge = 413,
+    UriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    ImATeapot = 418,
+    MisdirectedRequest = 421,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    TooEarly = 425,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    UnavailableForLegalReasons = 451,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511
+}

package/lib/types/services/http/http.service.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 { Disposable } from '@univerjs/core';
+import type { IDisposable } from '@wendellhu/redi';
+import type { Observable } from 'rxjs';
+import type { HTTPResponseType } from './http';
+import { IHTTPImplementation } from './implementations/implementation';
+import { HTTPRequest } from './request';
+import type { HTTPEvent } from './response';
+import { HTTPResponse } from './response';
+export interface IRequestParams {
+    body?: any;
+    /** Query params. These params would be append to the url before the request is sent. */
+    params?: {
+        [param: string]: string | number | boolean;
+    };
+    headers?: {
+        [key: string]: string | number | boolean;
+    };
+    responseType?: HTTPResponseType;
+    withCredentials?: boolean;
+}
+export interface IPostRequestParams extends IRequestParams {
+    body?: any;
+}
+type HTTPHandlerFn = (request: HTTPRequest) => Observable<HTTPEvent<unknown>>;
+type HTTPInterceptorFn = (request: HTTPRequest, next: HTTPHandlerFn) => Observable<HTTPEvent<unknown>>;
+/**
+ * Register an HTTP interceptor. Interceptor could modify requests, responses, headers or errors.
+ */
+export interface IHTTPInterceptor {
+    priority?: number;
+    interceptor: HTTPInterceptorFn;
+}
+export declare class HTTPService extends Disposable {
+    private readonly _http;
+    private _interceptors;
+    private _pipe;
+    constructor(_http: IHTTPImplementation);
+    registerHTTPInterceptor(interceptor: IHTTPInterceptor): IDisposable;
+    get<T>(url: string, options?: IRequestParams): Promise<HTTPResponse<T>>;
+    post<T>(url: string, options?: IPostRequestParams): Promise<HTTPResponse<T>>;
+    put<T>(url: string, options?: IPostRequestParams): Promise<HTTPResponse<T>>;
+    delete<T>(url: string, options?: IRequestParams): Promise<HTTPResponse<T>>;
+    /** The HTTP request implementations */
+    private _request;
+    private _runInterceptorsAndImplementation;
+}
+export {};

package/lib/types/services/http/implementations/implementation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 type { Observable } from 'rxjs';
+import type { HTTPRequest } from '../request';
+import type { HTTPEvent } from '../response';
+/**
+ * HTTP service could be implemented differently on platforms.
+ */
+export interface IHTTPImplementation {
+    send(request: HTTPRequest): Observable<HTTPEvent<any>>;
+}
+export declare const IHTTPImplementation: import("@wendellhu/redi").IdentifierDecorator<IHTTPImplementation>;

package/lib/types/services/http/implementations/xhr.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * 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 { Observable } from 'rxjs';
+import type { HTTPRequest } from '../request';
+import type { HTTPEvent } from '../response';
+import type { IHTTPImplementation } from './implementation';
+/**
+ * A HTTP implementation using XHR. XHR could only be async.
+ */
+export declare class XHRHTTPImplementation implements IHTTPImplementation {
+    send(request: HTTPRequest): Observable<HTTPEvent<any>>;
+}