@univerjs/network 0.1.0-alpha.3

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

@@ -0,0 +1,24 @@
+/**
+ * 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 declare class HTTPParams {
+    readonly params?: {
+        [key: string]: string | number | boolean;
+    } | undefined;
+    constructor(params?: {
+        [key: string]: string | number | boolean;
+    } | undefined);
+    toString(): string;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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 { HTTPHeaders } from './headers';
+import type { HTTPResponseType } from './http';
+import type { HTTPParams } from './params';
+export type HTTPRequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export interface IHTTPRequestParams {
+    body?: any;
+    headers: HTTPHeaders;
+    params?: HTTPParams;
+    responseType: HTTPResponseType;
+    withCredentials: boolean;
+}
+export declare class HTTPRequest {
+    readonly method: HTTPRequestMethod;
+    readonly url: string;
+    readonly requestParams?: IHTTPRequestParams | undefined;
+    get headers(): HTTPHeaders;
+    get withCredentials(): boolean;
+    get responseType(): string;
+    constructor(method: HTTPRequestMethod, url: string, requestParams?: IHTTPRequestParams | undefined);
+    getUrlWithParams(): string;
+    getBody(): string | null;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * 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 { HTTPHeaders } from './headers';
+/**
+ * There are multiple events could be resolved from the HTTP server.
+ */
+export type HTTPEvent<T> = HTTPResponse<T> | HTTPResponseError;
+/** Wraps (success) response info. */
+export declare class HTTPResponse<T> {
+    readonly body: T;
+    readonly headers: HTTPHeaders;
+    readonly status: number;
+    readonly statusText: string;
+    constructor({ body, headers, status, statusText, }: {
+        body: T;
+        headers: HTTPHeaders;
+        status: number;
+        statusText: string;
+    });
+}
+export declare class HTTPResponseError {
+    readonly headers: HTTPHeaders;
+    readonly status: number;
+    readonly statusText: string;
+    readonly error: any;
+    constructor({ headers, status, statusText, error, }: {
+        headers: HTTPHeaders;
+        status: number;
+        statusText: string;
+        error: any;
+    });
+}
+export declare class ResponseHeader {
+    readonly headers: HTTPHeaders;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(headers: HTTPHeaders, status: number, statusText: string);
+}

package/lib/types/services/web-socket/web-socket.service.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { Nullable } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+import { Observable } from 'rxjs';
+export type SocketBodyType = string | ArrayBufferLike | Blob | ArrayBufferView;
+/**
+ * This service is responsible for establishing bidi-directional connection to a remote server.
+ */
+export declare const ISocketService: import("@wendellhu/redi").IdentifierDecorator<ISocketService>;
+export interface ISocketService {
+    createSocket(url: string): Nullable<ISocket>;
+}
+/**
+ * An interface that represents a socket connection.
+ */
+export interface ISocket {
+    URL: string;
+    close(code?: number, reason?: string): void;
+    /**
+     * Send a message to the remote server.
+     */
+    send(data: SocketBodyType): void;
+    close$: Observable<CloseEvent>;
+    error$: Observable<Event>;
+    message$: Observable<MessageEvent>;
+    open$: Observable<Event>;
+}
+/**
+ * This service create a WebSocket connection to a remote server.
+ */
+export declare class WebSocketService extends Disposable implements ISocketService {
+    createSocket(URL: string): Nullable<ISocket>;
+}

package/lib/umd/index.js

@@ -0,0 +1,422 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@univerjs/core"), require("rxjs"), require("rxjs/operators"), require("@wendellhu/redi")) : typeof define === "function" && define.amd ? define(["exports", "@univerjs/core", "rxjs", "rxjs/operators", "@wendellhu/redi"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.UniverNetwork = {}, global.UniverCore, global.rxjs, global.rxjs.operators, global["@wendellhu/redi"]));
+})(this, function(exports2, core, rxjs, operators, redi) {
+  "use strict";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;
+};
+
+  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 = redi.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);
+  exports2.HTTPService = class HTTPService extends core.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 core.toDisposable(() => core.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$ = rxjs.of(request).pipe(
+        operators.concatMap((request2) => this._runInterceptorsAndImplementation(request2))
+      );
+      const result = await rxjs.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 */
+      );
+    }
+  };
+  exports2.HTTPService = __decorateClass([
+    __decorateParam(0, IHTTPImplementation)
+  ], exports2.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 rxjs.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 = redi.createIdentifier("univer.socket");
+  class WebSocketService extends core.Disposable {
+    createSocket(URL) {
+      try {
+        const connection = new WebSocket(URL);
+        const disposables = new core.DisposableCollection();
+        const webSocket = {
+          URL,
+          close: (code, reason) => {
+            connection.close(code, reason);
+            disposables.dispose();
+          },
+          send: (data) => {
+            connection.send(data);
+          },
+          open$: new rxjs.Observable((subscriber) => {
+            const callback = (event) => subscriber.next(event);
+            connection.addEventListener("open", callback);
+            disposables.add(core.toDisposable(() => connection.removeEventListener("open", callback)));
+          }).pipe(operators.share()),
+          close$: new rxjs.Observable((subscriber) => {
+            const callback = (event) => subscriber.next(event);
+            connection.addEventListener("close", callback);
+            disposables.add(core.toDisposable(() => connection.removeEventListener("close", callback)));
+          }).pipe(operators.share()),
+          error$: new rxjs.Observable((subscriber) => {
+            const callback = (event) => subscriber.next(event);
+            connection.addEventListener("error", callback);
+            disposables.add(core.toDisposable(() => connection.removeEventListener("error", callback)));
+          }).pipe(operators.share()),
+          message$: new rxjs.Observable((subscriber) => {
+            const callback = (event) => subscriber.next(event);
+            connection.addEventListener("message", callback);
+            disposables.add(core.toDisposable(() => connection.removeEventListener("message", callback)));
+          }).pipe(operators.share())
+        };
+        return webSocket;
+      } catch (e) {
+        console.error(e);
+        return null;
+      }
+    }
+  }
+  exports2.HTTPHeaders = HTTPHeaders;
+  exports2.HTTPRequest = HTTPRequest;
+  exports2.HTTPResponse = HTTPResponse;
+  exports2.IHTTPImplementation = IHTTPImplementation;
+  exports2.ISocketService = ISocketService;
+  exports2.WebSocketService = WebSocketService;
+  exports2.XHRHTTPImplementation = XHRHTTPImplementation;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@univerjs/network",
+  "version": "0.1.0-alpha.3",
+  "keywords": [],
+  "author": "DreamNum <developer@univer.ai>",
+  "license": "Apache-2.0",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/es/index.js",
+  "types": "./lib/types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./lib/es/index.js",
+      "require": "./lib/cjs/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./*": {
+      "import": "./lib/es/*",
+      "require": "./lib/cjs/*",
+      "types": "./lib/types/index.d.ts"
+    }
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "lib"
+  ],
+  "private": false,
+  "devDependencies": {
+    "@wendellhu/redi": "^0.12.12",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.8",
+    "vite-plugin-dts": "^3.6.4",
+    "vite-plugin-externals": "^0.6.2",
+    "vitest": "^1.0.4",
+    "@univerjs/core": "0.1.0-alpha.3"
+  },
+  "peerDependencies": {
+    "@wendellhu/redi": ">=0.12.12",
+    "rxjs": ">=7.0.0",
+    "@univerjs/core": "0.1.0-alpha.3"
+  },
+  "scripts": {
+    "build": "tsc && vite build"
+  }
+}