@univerjs/rpc 0.20.1 → 0.21.0

package/lib/es/index.js

@@ -1 +1,728 @@
-import{CommandType as e,Disposable as t,ICommandService as n,IConfigService as r,ILogService as i,IUniverInstanceService as a,Inject as o,Injector as s,Plugin as c,RxDisposable as l,UniverInstanceType as u,createIdentifier as d,merge as f,toDisposable as p}from"@univerjs/core";import{filter as m,take as ee,takeUntil as h}from"rxjs/operators";import{BehaviorSubject as g,Observable as _,firstValueFrom as v,isObservable as te,of as y,shareReplay as b}from"rxjs";const x=`rpc.main-thread.config`;Symbol(x);const S={},C=`rpc.worker-thread.config`;Symbol(C);const w={};function T(e,t){return function(n,r){t(n,r,e)}}function E(e,t,n,r){var i=arguments.length,a=i<3?t:r===null?r=Object.getOwnPropertyDescriptor(t,n):r,o;if(typeof Reflect==`object`&&typeof Reflect.decorate==`function`)a=Reflect.decorate(e,t,n,r);else for(var s=e.length-1;s>=0;s--)(o=e[s])&&(a=(i<3?o(a):i>3?o(t,n,a):o(t,n))||a);return i>3&&a&&Object.defineProperty(t,n,a),a}const D=`rpc.remote-sync.service`,O=d(D);let k=class{constructor(e){this._commandService=e}async syncMutation(e,t){let{fromCollab:n,...r}=t||{};return this._commandService.syncExecuteCommand(e.mutationInfo.id,e.mutationInfo.params,{...r,onlyLocal:!0,fromSync:!0})}};k=E([T(0,n)],k);const A=`univer.remote-instance-service`,j=d(A);let M=class{constructor(e,t,n){this._univerInstanceService=e,this._commandService=t,this._logService=n}whenReady(){return Promise.resolve(!0)}async syncMutation(e,t){return this._applyMutation(e.mutationInfo,t)}async createInstance(e){this._logService.debug(`[WebWorkerRemoteInstanceService]: Creating instance with id ${e.unitID}`);let{type:t,snapshot:n}=e;try{switch(t){case u.UNIVER_SHEET:return this._univerInstanceService.createUnit(u.UNIVER_SHEET,n),!0;default:throw Error(`[WebWorkerRemoteInstanceService]: cannot create replica for document type: ${t}.`)}}catch(e){throw e instanceof Error?e:TypeError(`${e}`)}}async disposeInstance(e){return this._logService.debug(`[WebWorkerRemoteInstanceService]: Disposing instance with id ${e.unitID}`),this._univerInstanceService.disposeUnit(e.unitID)}_applyMutation(e,t){let{id:n,params:r}=e,{fromCollab:i,...a}=t||{};return this._commandService.syncExecuteCommand(n,r,{...a,onlyLocal:!0,fromSync:!0})}};M=E([T(0,a),T(1,n),T(2,i)],M);function N(e){"@babel/helpers - typeof";return N=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},N(e)}function P(e,t){if(N(e)!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(N(r)!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function F(e){var t=P(e,`string`);return N(t)==`symbol`?t:t+``}function I(e,t,n){return(t=F(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function L(e){let t=e;return new class{call(e,n){let r=t[e];if(typeof r==`function`){let e=n?r.apply(t,n):r.call(t);return e instanceof Promise||(e=Promise.resolve(e)),e}throw Error(`[RPC]: method not found for ${e}!`)}subscribe(e,n){let r=t[e];if(typeof r==`function`){let e=n?r.apply(t,n):r.call(t);return te(e)?e:y(e)}throw Error(`[RPC]: observable method not found for ${e}!`)}}}function R(e){return new Proxy({},{get(t,n){if(n!==`dispose`)return function(...t){return z(n)?e.subscribe(n,t):e.call(n,t)}}})}function z(e){return e.endsWith(`$`)}var B=function(e){return e[e.REQUEST_INITIALIZATION=50]=`REQUEST_INITIALIZATION`,e[e.CALL=100]=`CALL`,e[e.SUBSCRIBE=101]=`SUBSCRIBE`,e[e.UNSUBSCRIBE=102]=`UNSUBSCRIBE`,e}(B||{}),V=function(e){return e[e.INITIALIZE=0]=`INITIALIZE`,e[e.CALL_SUCCESS=201]=`CALL_SUCCESS`,e[e.CALL_FAILURE=202]=`CALL_FAILURE`,e[e.SUBSCRIBE_NEXT=300]=`SUBSCRIBE_NEXT`,e[e.SUBSCRIBE_ERROR=301]=`SUBSCRIBE_ERROR`,e[e.SUBSCRIBE_COMPLETE=302]=`SUBSCRIBE_COMPLETE`,e}(V||{}),H=class extends l{constructor(e){super(),this._protocol=e,I(this,`_initialized`,new g(!1)),I(this,`_lastRequestCounter`,0),I(this,`_pendingRequests`,new Map),this._protocol.send({type:B.REQUEST_INITIALIZATION}),this._protocol.onMessage.pipe(h(this.dispose$)).subscribe(e=>this._onMessage(e))}dispose(){this._pendingRequests.clear()}getChannel(e){return{call:(t,n)=>this._disposed?Promise.reject(Error(`[ChannelClient]: client is disposed!`)):this._remoteCall(e,t,n),subscribe:(t,n)=>{if(this._disposed)throw Error(`[ChannelClient]: client is disposed!`);return this._remoteSubscribe(e,t,n)}}}_whenReady(){return v(this._initialized.pipe(m(e=>e),ee(1)))}_remoteCall(e,t,n){return this._initialized.getValue()?this._doRemoteCall(e,t,n):this._whenReady().then(()=>this._doRemoteCall(e,t,n))}_doRemoteCall(e,t,n){let r=++this._lastRequestCounter,i={seq:r,type:B.CALL,channelName:e,method:t,args:n},a=this._pendingRequests;return new Promise((e,t)=>{this._pendingRequests.set(r,{handle(n){switch(n.type){case V.CALL_SUCCESS:a.delete(r),e(n.data);break;case V.CALL_FAILURE:a.delete(r),t(n.data);break;default:throw Error(`[ChannelClient]: unknown response type!`)}}}),this._sendRequest(i)})}_remoteSubscribe(e,t,n){return new _(r=>{let i=-1,a=()=>{i=++this._lastRequestCounter;let a=B.SUBSCRIBE,o={seq:i,type:a,channelName:e,method:t,args:n};this._pendingRequests.set(i,{handle(e){switch(e.type){case V.SUBSCRIBE_NEXT:r.next(e.data);break;case V.SUBSCRIBE_ERROR:r.error(e.data);break;case V.SUBSCRIBE_COMPLETE:r.complete();break;default:throw Error(`[ChannelClient]: unknown response type!`)}}}),this._sendRequest(o)};return this._initialized.getValue()?a():this._whenReady().then(a),()=>{if(i===-1)return;let n={type:B.UNSUBSCRIBE,seq:i,channelName:e,method:t};this._sendRequest(n)}})}_sendRequest(e){this._protocol.send(e)}_onMessage(e){let{type:t,seq:n}=e;switch(t){case V.INITIALIZE:this._initialized.next(!0);break;case V.CALL_SUCCESS:case V.CALL_FAILURE:case V.SUBSCRIBE_NEXT:case V.SUBSCRIBE_COMPLETE:case V.SUBSCRIBE_ERROR:{var r;let{_pendingRequests:i}=this;(r=i.get(n))==null||r.handle(e),t!==V.SUBSCRIBE_NEXT&&i.delete(n);break}}}},U=class extends l{constructor(e){super(),this._protocol=e,I(this,`_channels`,new Map),I(this,`_subscriptions`,new Map),this._protocol.onMessage.pipe(h(this.dispose$)).subscribe(e=>this._onRequest(e)),this._sendInitialize()}dispose(){super.dispose(),this._subscriptions.clear(),this._channels.clear()}registerChannel(e,t){this._channels.set(e,t)}_onRequest(e){switch(e.type){case B.REQUEST_INITIALIZATION:this._sendInitialize();break;case B.CALL:this._onMethodCall(e);break;case B.SUBSCRIBE:this._onSubscribe(e);break;case B.UNSUBSCRIBE:this._onUnsubscribe(e);break;default:break}}_sendInitialize(){this._sendResponse({seq:-1,type:V.INITIALIZE})}_onMethodCall(e){let{channelName:t,method:n,args:r}=e,i=this._channels.get(t),a;try{if(!i)throw Error(`[ChannelServer]: Channel ${t} not found!`);a=r?i.call(n,r):i.call(n)}catch(e){a=Promise.reject(e instanceof Error?e:Error(String(e)))}a.then(t=>{this._sendResponse({seq:e.seq,type:V.CALL_SUCCESS,data:t})}).catch(t=>{t instanceof Error?this._sendResponse({seq:e.seq,type:V.CALL_FAILURE,data:t.message}):this._sendResponse({seq:e.seq,type:V.CALL_FAILURE,data:String(t)})})}_onSubscribe(e){let{channelName:t,seq:n}=e,r=this._channels.get(t);try{if(!r)throw Error(`[ChannelServer]: Channel ${t} not found!`);let i=r.subscribe(e.method,e.args).subscribe({next:e=>{this._sendResponse({seq:n,type:V.SUBSCRIBE_NEXT,data:e})},error:e=>{this._sendResponse({seq:n,type:V.SUBSCRIBE_ERROR,data:e.message}),this._sendResponse({seq:n,type:V.SUBSCRIBE_COMPLETE})},complete:()=>{this._sendResponse({seq:n,type:V.SUBSCRIBE_COMPLETE})}});this._subscriptions.set(e.seq,i)}catch(t){t instanceof Error?this._sendResponse({seq:e.seq,type:V.SUBSCRIBE_ERROR,data:t.message}):this._sendResponse({seq:e.seq,type:V.SUBSCRIBE_ERROR,data:String(t)})}}_onUnsubscribe(e){let t=this._subscriptions.get(e.seq);t&&(t.unsubscribe(),this._subscriptions.delete(e.seq))}_sendResponse(e){this._protocol.send(e)}};const W=d(`IRPCChannelService`);var G=class{constructor(e){I(this,`_client`,void 0),I(this,`_server`,void 0),this._client=new H(e),this._server=new U(e)}dispose(){this._client.dispose(),this._server.dispose()}requestChannel(e){return this._client.getChannel(e)}registerChannel(e,t){this._server.registerChannel(e,t)}};let K=class extends l{constructor(e,t,n,r,i){super(),this._injector=e,this._commandService=t,this._univerInstanceService=n,this._rpcChannelService=r,this._remoteSyncService=i,I(this,`_remoteInstanceService`,void 0),I(this,`_syncingUnits`,new Set),I(this,`_syncingMutations`,new Set),this._initRPCChannels(),this._init()}registerSyncingMutations(e){this._syncingMutations.add(e.id)}syncUnit(e){return this._syncingUnits.add(e),p(()=>this._syncingUnits.delete(e))}_initRPCChannels(){this._rpcChannelService.registerChannel(D,L(this._remoteSyncService)),this._injector.add([j,{useFactory:()=>R(this._rpcChannelService.requestChannel(A))}]),this._remoteInstanceService=this._injector.get(j)}_init(){this._univerInstanceService.getTypeOfUnitAdded$(u.UNIVER_SHEET).pipe(h(this.dispose$)).subscribe(e=>{this._syncingUnits.add(e.getUnitId()),this._remoteInstanceService.createInstance({unitID:e.getUnitId(),type:u.UNIVER_SHEET,snapshot:e.getSnapshot()})}),this._univerInstanceService.getTypeOfUnitDisposed$(u.UNIVER_SHEET).pipe(h(this.dispose$)).subscribe(e=>{this._syncingUnits.delete(e.getUnitId()),this._remoteInstanceService.disposeInstance({unitID:e.getUnitId()})}),this.disposeWithMe(this._commandService.onCommandExecuted((t,n)=>{let{type:r,params:i,id:a}=t,o=(i==null?void 0:i.unitId)||``;r===e.MUTATION&&(!o||this._syncingUnits.has(o))&&!(n!=null&&n.fromSync)&&this._syncingMutations.has(a)&&this._remoteInstanceService.syncMutation({mutationInfo:t},n)}))}};K=E([T(0,o(s)),T(1,n),T(2,a),T(3,W),T(4,O)],K);let q=class extends t{constructor(e,t,n,r){super(),this._injector=e,this._remoteInstanceService=t,this._commandService=n,this._rpcChannelService=r,I(this,`_remoteSyncService`,void 0),this._initRPCChannels(),this._init()}_initRPCChannels(){this._rpcChannelService.registerChannel(A,L(this._remoteInstanceService)),this._injector.add([O,{useFactory:()=>R(this._rpcChannelService.requestChannel(D))}]),this._remoteSyncService=this._injector.get(O)}_init(){this.disposeWithMe(this._commandService.onCommandExecuted((t,n)=>{t.type===e.MUTATION&&!(n!=null&&n.fromSync)&&this._remoteSyncService.syncMutation({mutationInfo:t},n)}))}};q=E([T(0,o(s)),T(1,j),T(2,n),T(3,W)],q);var J=`@univerjs/rpc`,Y=`0.20.1`;function X(){return{send(e){postMessage(e)},onMessage:new _(e=>{let t=t=>{e.next(t.data)};return addEventListener(`message`,t),()=>removeEventListener(`message`,t)}).pipe(b(1))}}function Z(e){return{send(t){e.postMessage(t)},onMessage:new _(t=>{let n=e=>{t.next(e.data)};return e.addEventListener(`message`,n),()=>e.removeEventListener(`message`,n)}).pipe(b(1))}}let Q=class extends c{constructor(e=S,t,n){super(),this._config=e,this._injector=t,this._configService=n,I(this,`_internalWorker`,null);let{...r}=f({},S,this._config);this._configService.setConfig(x,r)}dispose(){super.dispose(),this._internalWorker&&(this._internalWorker.terminate(),this._internalWorker=null)}onStarting(){let{workerURL:e}=this._config;if(!e)throw Error(`[UniverRPCMainThreadPlugin]: The workerURL is required for the RPC main thread plugin.`);let t=e instanceof Worker?e:new Worker(e);this._internalWorker=e instanceof Worker?null:t;let n=Z(t);[[W,{useFactory:()=>new G(n)}],[K],[O,{useClass:k}]].forEach(e=>this._injector.add(e)),this._injector.get(K)}};I(Q,`pluginName`,`UNIVER_RPC_MAIN_THREAD_PLUGIN`),I(Q,`packageName`,J),I(Q,`version`,Y),Q=E([T(1,o(s)),T(2,r)],Q);let $=class extends c{constructor(e=w,t,n){super(),this._config=e,this._injector=t,this._configService=n;let{...r}=f({},w,this._config);this._configService.setConfig(C,r)}onStarting(){[[q],[W,{useFactory:()=>new G(X())}],[j,{useClass:M}]].forEach(e=>this._injector.add(e)),this._injector.get(q)}};I($,`pluginName`,`UNIVER_RPC_WORKER_THREAD_PLUGIN`),I($,`packageName`,J),I($,`version`,Y),$=E([T(1,o(s)),T(2,r)],$);export{H as ChannelClient,U as ChannelServer,G as ChannelService,K as DataSyncPrimaryController,q as DataSyncReplicaController,W as IRPCChannelService,j as IRemoteInstanceService,O as IRemoteSyncService,x as PLUGIN_CONFIG_KEY_MAIN_THREAD,C as PLUGIN_CONFIG_KEY_WORKER_THREAD,A as RemoteInstanceServiceName,k as RemoteSyncPrimaryService,D as RemoteSyncServiceName,Q as UniverRPCMainThreadPlugin,$ as UniverRPCWorkerThreadPlugin,M as WebWorkerRemoteInstanceService,L as fromModule,R as toModule};
+import { CommandType, Disposable, ICommandService, IConfigService, ILogService, IUniverInstanceService, Inject, Injector, Plugin, RxDisposable, UniverInstanceType, createIdentifier, merge, toDisposable } from "@univerjs/core";
+import { filter, take, takeUntil } from "rxjs/operators";
+import { BehaviorSubject, Observable, firstValueFrom, isObservable, of, shareReplay } from "rxjs";
+
+//#region src/config/config.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* 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.
+*/
+const PLUGIN_CONFIG_KEY_MAIN_THREAD = "rpc.main-thread.config";
+const configSymbolMainThread = Symbol(PLUGIN_CONFIG_KEY_MAIN_THREAD);
+const defaultPluginMainThreadConfig = {};
+const PLUGIN_CONFIG_KEY_WORKER_THREAD = "rpc.worker-thread.config";
+const configSymbolWorkerThread = Symbol(PLUGIN_CONFIG_KEY_WORKER_THREAD);
+const defaultPluginWorkerThreadConfig = {};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/services/remote-instance/remote-instance.service.ts
+const RemoteSyncServiceName = "rpc.remote-sync.service";
+/**
+* This service is provided by the primary Univer.
+*
+* Replica Univer could call this service to update mutations back to the primary Univer.
+*/
+const IRemoteSyncService = createIdentifier(RemoteSyncServiceName);
+let RemoteSyncPrimaryService = class RemoteSyncPrimaryService {
+	constructor(_commandService) {
+		this._commandService = _commandService;
+	}
+	async syncMutation(params, options) {
+		const { fromCollab, ...restOptions } = options || {};
+		return this._commandService.syncExecuteCommand(params.mutationInfo.id, params.mutationInfo.params, {
+			...restOptions,
+			onlyLocal: true,
+			fromSync: true
+		});
+	}
+};
+RemoteSyncPrimaryService = __decorate([__decorateParam(0, ICommandService)], RemoteSyncPrimaryService);
+const RemoteInstanceServiceName = "univer.remote-instance-service";
+/**
+* This service is provided by the replica Univer.
+*
+* Primary univer could call this service to init and dispose univer business instances
+* and sync mutations to replica univer.
+*/
+const IRemoteInstanceService = createIdentifier(RemoteInstanceServiceName);
+let WebWorkerRemoteInstanceService = class WebWorkerRemoteInstanceService {
+	constructor(_univerInstanceService, _commandService, _logService) {
+		this._univerInstanceService = _univerInstanceService;
+		this._commandService = _commandService;
+		this._logService = _logService;
+	}
+	whenReady() {
+		return Promise.resolve(true);
+	}
+	async syncMutation(params, options) {
+		return this._applyMutation(params.mutationInfo, options);
+	}
+	async createInstance(params) {
+		this._logService.debug(`[WebWorkerRemoteInstanceService]: Creating instance with id ${params.unitID}`);
+		const { type, snapshot } = params;
+		try {
+			switch (type) {
+				case UniverInstanceType.UNIVER_SHEET:
+					this._univerInstanceService.createUnit(UniverInstanceType.UNIVER_SHEET, snapshot);
+					return true;
+				default: throw new Error(`[WebWorkerRemoteInstanceService]: cannot create replica for document type: ${type}.`);
+			}
+		} catch (err) {
+			if (err instanceof Error) throw err;
+			else throw new TypeError(`${err}`);
+		}
+	}
+	async disposeInstance(params) {
+		this._logService.debug(`[WebWorkerRemoteInstanceService]: Disposing instance with id ${params.unitID}`);
+		return this._univerInstanceService.disposeUnit(params.unitID);
+	}
+	_applyMutation(mutationInfo, options) {
+		const { id, params: mutationParams } = mutationInfo;
+		const { fromCollab, ...restOptions } = options || {};
+		return this._commandService.syncExecuteCommand(id, mutationParams, {
+			...restOptions,
+			onlyLocal: true,
+			fromSync: true
+		});
+	}
+};
+WebWorkerRemoteInstanceService = __decorate([
+	__decorateParam(0, IUniverInstanceService),
+	__decorateParam(1, ICommandService),
+	__decorateParam(2, ILogService)
+], WebWorkerRemoteInstanceService);
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/services/rpc/rpc.service.ts
+/**
+* Wrapper a service or a controller into a channel so it could be invoked by
+* a remote client. When the protocol is called, it would forward to the
+* underlying service or controller.
+*
+* @param module the wrapper service or controller
+* @returns the channel instance
+*/
+function fromModule(module) {
+	const handler = module;
+	return new class {
+		call(method, args) {
+			const target = handler[method];
+			if (typeof target === "function") {
+				let res = args ? target.apply(handler, args) : target.call(handler);
+				if (!(res instanceof Promise)) res = Promise.resolve(res);
+				return res;
+			}
+			throw new Error(`[RPC]: method not found for ${method}!`);
+		}
+		subscribe(eventMethod, args) {
+			const target = handler[eventMethod];
+			if (typeof target === "function") {
+				const res = args ? target.apply(handler, args) : target.call(handler);
+				if (!isObservable(res)) return of(res);
+				return res;
+			}
+			throw new Error(`[RPC]: observable method not found for ${eventMethod}!`);
+		}
+	}();
+}
+/**
+* Wrap a channel into a service or a controller so it could be invoked by
+* the upper layer modules. When the service or controller is called, it would
+* request the remote server by calling the channel.
+*
+* @param channel
+* @returns A proxy object that forwards calls/subscriptions to the remote channel.
+*/
+function toModule(channel) {
+	return new Proxy({}, { get(_, propKey) {
+		if (propKey === "dispose") return;
+		return function(...args) {
+			if (propertyIsEventSource(propKey)) return channel.subscribe(propKey, args);
+			return channel.call(propKey, args);
+		};
+	} });
+}
+function propertyIsEventSource(name) {
+	return name.endsWith("$");
+}
+var RequestType = /* @__PURE__ */ function(RequestType) {
+	/**
+	* In Univer, we cannot make sure that when IPCServer constructs, the process (or thread)
+	* where the corresponding IPCClient residents has bootstrapped and been ready to recieve messages.
+	* This may result in the IPCClient hanging there, waiting for the `INITIALIZE` message that it has
+	* already missed. So the client should send a REQUEST_INITIALIZATION in case of that.
+	*
+	* Later, we may want a more sophisticated RPC system where the server can serve more than
+	* one clients, and this event may be removed.
+	*/
+	RequestType[RequestType["REQUEST_INITIALIZATION"] = 50] = "REQUEST_INITIALIZATION";
+	/** A simple remote calling wrapper in a Promise. */
+	RequestType[RequestType["CALL"] = 100] = "CALL";
+	/** Subscribe to a remote Observable. */
+	RequestType[RequestType["SUBSCRIBE"] = 101] = "SUBSCRIBE";
+	/** Cancel subscription to that remove Observable. */
+	RequestType[RequestType["UNSUBSCRIBE"] = 102] = "UNSUBSCRIBE";
+	return RequestType;
+}(RequestType || {});
+var ResponseType = /* @__PURE__ */ function(ResponseType) {
+	/**
+	* When underlying protocol is established. The server should send the
+	* client an `INITIALIZE` response to indicate that the server is up
+	* and ready to provide services.
+	*/
+	ResponseType[ResponseType["INITIALIZE"] = 0] = "INITIALIZE";
+	ResponseType[ResponseType["CALL_SUCCESS"] = 201] = "CALL_SUCCESS";
+	ResponseType[ResponseType["CALL_FAILURE"] = 202] = "CALL_FAILURE";
+	ResponseType[ResponseType["SUBSCRIBE_NEXT"] = 300] = "SUBSCRIBE_NEXT";
+	ResponseType[ResponseType["SUBSCRIBE_ERROR"] = 301] = "SUBSCRIBE_ERROR";
+	ResponseType[ResponseType["SUBSCRIBE_COMPLETE"] = 302] = "SUBSCRIBE_COMPLETE";
+	return ResponseType;
+}(ResponseType || {});
+/**
+* This method provides implementation for `IChannel` and is responsible for
+* transforming a local calling to a RPC calling.
+*/
+var ChannelClient = class extends RxDisposable {
+	constructor(_protocol) {
+		super();
+		this._protocol = _protocol;
+		_defineProperty(this, "_initialized", new BehaviorSubject(false));
+		_defineProperty(this, "_lastRequestCounter", 0);
+		_defineProperty(this, "_pendingRequests", /* @__PURE__ */ new Map());
+		this._protocol.send({ type: RequestType.REQUEST_INITIALIZATION });
+		this._protocol.onMessage.pipe(takeUntil(this.dispose$)).subscribe((message) => this._onMessage(message));
+	}
+	dispose() {
+		this._pendingRequests.clear();
+	}
+	getChannel(channelName) {
+		return {
+			call: (method, args) => {
+				if (this._disposed) return Promise.reject(/* @__PURE__ */ new Error("[ChannelClient]: client is disposed!"));
+				return this._remoteCall(channelName, method, args);
+			},
+			subscribe: (eventMethod, args) => {
+				if (this._disposed) throw new Error("[ChannelClient]: client is disposed!");
+				return this._remoteSubscribe(channelName, eventMethod, args);
+			}
+		};
+	}
+	_whenReady() {
+		return firstValueFrom(this._initialized.pipe(filter((v) => v), take(1)));
+	}
+	_remoteCall(channelName, method, args) {
+		if (this._initialized.getValue()) return this._doRemoteCall(channelName, method, args);
+		return this._whenReady().then(() => this._doRemoteCall(channelName, method, args));
+	}
+	_doRemoteCall(channelName, method, args) {
+		const sequence = ++this._lastRequestCounter;
+		const request = {
+			seq: sequence,
+			type: RequestType.CALL,
+			channelName,
+			method,
+			args
+		};
+		const pendingRequests = this._pendingRequests;
+		return new Promise((resolve, reject) => {
+			this._pendingRequests.set(sequence, { handle(response) {
+				switch (response.type) {
+					case ResponseType.CALL_SUCCESS:
+						pendingRequests.delete(sequence);
+						resolve(response.data);
+						break;
+					case ResponseType.CALL_FAILURE:
+						pendingRequests.delete(sequence);
+						reject(response.data);
+						break;
+					default: throw new Error("[ChannelClient]: unknown response type!");
+				}
+			} });
+			this._sendRequest(request);
+		});
+	}
+	_remoteSubscribe(channelName, method, args) {
+		return new Observable((subscriber) => {
+			let sequence = -1;
+			const doSubscribe = () => {
+				sequence = ++this._lastRequestCounter;
+				const type = RequestType.SUBSCRIBE;
+				const request = {
+					seq: sequence,
+					type,
+					channelName,
+					method,
+					args
+				};
+				this._pendingRequests.set(sequence, { handle(response) {
+					switch (response.type) {
+						case ResponseType.SUBSCRIBE_NEXT:
+							subscriber.next(response.data);
+							break;
+						case ResponseType.SUBSCRIBE_ERROR:
+							subscriber.error(response.data);
+							break;
+						case ResponseType.SUBSCRIBE_COMPLETE:
+							subscriber.complete();
+							break;
+						default: throw new Error("[ChannelClient]: unknown response type!");
+					}
+				} });
+				this._sendRequest(request);
+			};
+			if (this._initialized.getValue()) doSubscribe();
+			else this._whenReady().then(doSubscribe);
+			return () => {
+				if (sequence === -1) return;
+				const cancelSubscriptionRequest = {
+					type: RequestType.UNSUBSCRIBE,
+					seq: sequence,
+					channelName,
+					method
+				};
+				this._sendRequest(cancelSubscriptionRequest);
+			};
+		});
+	}
+	_sendRequest(request) {
+		this._protocol.send(request);
+	}
+	_onMessage(response) {
+		const { type: responseType, seq } = response;
+		switch (responseType) {
+			case ResponseType.INITIALIZE:
+				this._initialized.next(true);
+				break;
+			case ResponseType.CALL_SUCCESS:
+			case ResponseType.CALL_FAILURE:
+			case ResponseType.SUBSCRIBE_NEXT:
+			case ResponseType.SUBSCRIBE_COMPLETE:
+			case ResponseType.SUBSCRIBE_ERROR: {
+				var _pendingRequests$get;
+				const { _pendingRequests } = this;
+				(_pendingRequests$get = _pendingRequests.get(seq)) === null || _pendingRequests$get === void 0 || _pendingRequests$get.handle(response);
+				responseType !== ResponseType.SUBSCRIBE_NEXT && _pendingRequests.delete(seq);
+				break;
+			}
+		}
+	}
+};
+var ChannelServer = class extends RxDisposable {
+	constructor(_protocol) {
+		super();
+		this._protocol = _protocol;
+		_defineProperty(this, "_channels", /* @__PURE__ */ new Map());
+		_defineProperty(this, "_subscriptions", /* @__PURE__ */ new Map());
+		this._protocol.onMessage.pipe(takeUntil(this.dispose$)).subscribe((message) => this._onRequest(message));
+		this._sendInitialize();
+	}
+	dispose() {
+		super.dispose();
+		this._subscriptions.clear();
+		this._channels.clear();
+	}
+	registerChannel(channelName, channel) {
+		this._channels.set(channelName, channel);
+	}
+	_onRequest(request) {
+		switch (request.type) {
+			case RequestType.REQUEST_INITIALIZATION:
+				this._sendInitialize();
+				break;
+			case RequestType.CALL:
+				this._onMethodCall(request);
+				break;
+			case RequestType.SUBSCRIBE:
+				this._onSubscribe(request);
+				break;
+			case RequestType.UNSUBSCRIBE:
+				this._onUnsubscribe(request);
+				break;
+			default: break;
+		}
+	}
+	_sendInitialize() {
+		this._sendResponse({
+			seq: -1,
+			type: ResponseType.INITIALIZE
+		});
+	}
+	_onMethodCall(request) {
+		const { channelName, method, args } = request;
+		const channel = this._channels.get(channelName);
+		let promise;
+		try {
+			if (!channel) throw new Error(`[ChannelServer]: Channel ${channelName} not found!`);
+			promise = args ? channel.call(method, args) : channel.call(method);
+		} catch (err) {
+			promise = Promise.reject(err instanceof Error ? err : new Error(String(err)));
+		}
+		promise.then((data) => {
+			this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_SUCCESS,
+				data
+			});
+		}).catch((err) => {
+			if (err instanceof Error) this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_FAILURE,
+				data: err.message
+			});
+			else this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_FAILURE,
+				data: String(err)
+			});
+		});
+	}
+	_onSubscribe(request) {
+		const { channelName, seq } = request;
+		const channel = this._channels.get(channelName);
+		try {
+			if (!channel) throw new Error(`[ChannelServer]: Channel ${channelName} not found!`);
+			const subscription = channel.subscribe(request.method, request.args).subscribe({
+				next: (data) => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_NEXT,
+						data
+					});
+				},
+				error: (err) => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_ERROR,
+						data: err.message
+					});
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_COMPLETE
+					});
+				},
+				complete: () => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_COMPLETE
+					});
+				}
+			});
+			this._subscriptions.set(request.seq, subscription);
+		} catch (err) {
+			if (err instanceof Error) this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.SUBSCRIBE_ERROR,
+				data: err.message
+			});
+			else this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.SUBSCRIBE_ERROR,
+				data: String(err)
+			});
+		}
+	}
+	_onUnsubscribe(request) {
+		const subscription = this._subscriptions.get(request.seq);
+		if (subscription) {
+			subscription.unsubscribe();
+			this._subscriptions.delete(request.seq);
+		}
+	}
+	_sendResponse(response) {
+		this._protocol.send(response);
+	}
+};
+
+//#endregion
+//#region src/services/rpc/channel.service.ts
+const IRPCChannelService = createIdentifier("IRPCChannelService");
+/**
+* This service is responsible for managing the RPC channels.
+*/
+var ChannelService = class {
+	constructor(_messageProtocol) {
+		_defineProperty(this, "_client", void 0);
+		_defineProperty(this, "_server", void 0);
+		this._client = new ChannelClient(_messageProtocol);
+		this._server = new ChannelServer(_messageProtocol);
+	}
+	dispose() {
+		this._client.dispose();
+		this._server.dispose();
+	}
+	requestChannel(name) {
+		return this._client.getChannel(name);
+	}
+	registerChannel(name, channel) {
+		this._server.registerChannel(name, channel);
+	}
+};
+
+//#endregion
+//#region src/controllers/data-sync/data-sync-primary.controller.ts
+let DataSyncPrimaryController = class DataSyncPrimaryController extends RxDisposable {
+	constructor(_injector, _commandService, _univerInstanceService, _rpcChannelService, _remoteSyncService) {
+		super();
+		this._injector = _injector;
+		this._commandService = _commandService;
+		this._univerInstanceService = _univerInstanceService;
+		this._rpcChannelService = _rpcChannelService;
+		this._remoteSyncService = _remoteSyncService;
+		_defineProperty(this, "_remoteInstanceService", void 0);
+		_defineProperty(this, "_syncingUnits", /* @__PURE__ */ new Set());
+		_defineProperty(this, "_syncingMutations", /* @__PURE__ */ new Set());
+		this._initRPCChannels();
+		this._init();
+	}
+	registerSyncingMutations(mutation) {
+		this._syncingMutations.add(mutation.id);
+	}
+	/**
+	* Only spreadsheets would be synced to the web worker in normal situations. If you would like to
+	* sync other types of documents, you should manually call this method with that document's id.
+	*/
+	syncUnit(unitId) {
+		this._syncingUnits.add(unitId);
+		return toDisposable(() => this._syncingUnits.delete(unitId));
+	}
+	_initRPCChannels() {
+		this._rpcChannelService.registerChannel(RemoteSyncServiceName, fromModule(this._remoteSyncService));
+		this._injector.add([IRemoteInstanceService, { useFactory: () => toModule(this._rpcChannelService.requestChannel(RemoteInstanceServiceName)) }]);
+		this._remoteInstanceService = this._injector.get(IRemoteInstanceService);
+	}
+	_init() {
+		this._univerInstanceService.getTypeOfUnitAdded$(UniverInstanceType.UNIVER_SHEET).pipe(takeUntil(this.dispose$)).subscribe((sheet) => {
+			this._syncingUnits.add(sheet.getUnitId());
+			this._remoteInstanceService.createInstance({
+				unitID: sheet.getUnitId(),
+				type: UniverInstanceType.UNIVER_SHEET,
+				snapshot: sheet.getSnapshot()
+			});
+		});
+		this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_SHEET).pipe(takeUntil(this.dispose$)).subscribe((workbook) => {
+			this._syncingUnits.delete(workbook.getUnitId());
+			this._remoteInstanceService.disposeInstance({ unitID: workbook.getUnitId() });
+		});
+		this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo, options) => {
+			const { type, params, id } = commandInfo;
+			const unitId = (params === null || params === void 0 ? void 0 : params.unitId) || "";
+			if (type === CommandType.MUTATION && (!unitId || this._syncingUnits.has(unitId)) && !(options === null || options === void 0 ? void 0 : options.fromSync) && this._syncingMutations.has(id)) this._remoteInstanceService.syncMutation({ mutationInfo: commandInfo }, options);
+		}));
+	}
+};
+DataSyncPrimaryController = __decorate([
+	__decorateParam(0, Inject(Injector)),
+	__decorateParam(1, ICommandService),
+	__decorateParam(2, IUniverInstanceService),
+	__decorateParam(3, IRPCChannelService),
+	__decorateParam(4, IRemoteSyncService)
+], DataSyncPrimaryController);
+
+//#endregion
+//#region src/controllers/data-sync/data-sync-replica.controller.ts
+let DataSyncReplicaController = class DataSyncReplicaController extends Disposable {
+	constructor(_injector, _remoteInstanceService, _commandService, _rpcChannelService) {
+		super();
+		this._injector = _injector;
+		this._remoteInstanceService = _remoteInstanceService;
+		this._commandService = _commandService;
+		this._rpcChannelService = _rpcChannelService;
+		_defineProperty(this, "_remoteSyncService", void 0);
+		this._initRPCChannels();
+		this._init();
+	}
+	_initRPCChannels() {
+		this._rpcChannelService.registerChannel(RemoteInstanceServiceName, fromModule(this._remoteInstanceService));
+		this._injector.add([IRemoteSyncService, { useFactory: () => toModule(this._rpcChannelService.requestChannel(RemoteSyncServiceName)) }]);
+		this._remoteSyncService = this._injector.get(IRemoteSyncService);
+	}
+	_init() {
+		this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo, options) => {
+			if (commandInfo.type === CommandType.MUTATION && !(options === null || options === void 0 ? void 0 : options.fromSync)) this._remoteSyncService.syncMutation({ mutationInfo: commandInfo }, options);
+		}));
+	}
+};
+DataSyncReplicaController = __decorate([
+	__decorateParam(0, Inject(Injector)),
+	__decorateParam(1, IRemoteInstanceService),
+	__decorateParam(2, ICommandService),
+	__decorateParam(3, IRPCChannelService)
+], DataSyncReplicaController);
+
+//#endregion
+//#region package.json
+var name = "@univerjs/rpc";
+var version = "0.21.0";
+
+//#endregion
+//#region src/services/rpc/implementations/web-worker-rpc.service.ts
+/**
+* Generate an `IMessageProtocol` on the web worker.
+* @returns A protocol wrapper around worker global messaging APIs.
+*/
+function createWebWorkerMessagePortOnWorker() {
+	return {
+		send(message) {
+			postMessage(message);
+		},
+		onMessage: new Observable((subscriber) => {
+			const handler = (event) => {
+				subscriber.next(event.data);
+			};
+			addEventListener("message", handler);
+			return () => removeEventListener("message", handler);
+		}).pipe(shareReplay(1))
+	};
+}
+/**
+* Generate an `IMessageProtocol` on the main thread side.
+* @param worker The Web Worker object
+* @returns A protocol wrapper around the given worker messaging APIs.
+*/
+function createWebWorkerMessagePortOnMain(worker) {
+	return {
+		send(message) {
+			worker.postMessage(message);
+		},
+		onMessage: new Observable((subscriber) => {
+			const handler = (event) => {
+				subscriber.next(event.data);
+			};
+			worker.addEventListener("message", handler);
+			return () => worker.removeEventListener("message", handler);
+		}).pipe(shareReplay(1))
+	};
+}
+
+//#endregion
+//#region src/plugin.ts
+let UniverRPCMainThreadPlugin = class UniverRPCMainThreadPlugin extends Plugin {
+	constructor(_config = defaultPluginMainThreadConfig, _injector, _configService) {
+		super();
+		this._config = _config;
+		this._injector = _injector;
+		this._configService = _configService;
+		_defineProperty(this, "_internalWorker", null);
+		const { ...rest } = merge({}, defaultPluginMainThreadConfig, this._config);
+		this._configService.setConfig(PLUGIN_CONFIG_KEY_MAIN_THREAD, rest);
+	}
+	dispose() {
+		super.dispose();
+		if (this._internalWorker) {
+			this._internalWorker.terminate();
+			this._internalWorker = null;
+		}
+	}
+	onStarting() {
+		const { workerURL } = this._config;
+		if (!workerURL) throw new Error("[UniverRPCMainThreadPlugin]: The workerURL is required for the RPC main thread plugin.");
+		const worker = workerURL instanceof Worker ? workerURL : new Worker(workerURL);
+		this._internalWorker = workerURL instanceof Worker ? null : worker;
+		const messageProtocol = createWebWorkerMessagePortOnMain(worker);
+		[
+			[IRPCChannelService, { useFactory: () => new ChannelService(messageProtocol) }],
+			[DataSyncPrimaryController],
+			[IRemoteSyncService, { useClass: RemoteSyncPrimaryService }]
+		].forEach((dependency) => this._injector.add(dependency));
+		this._injector.get(DataSyncPrimaryController);
+	}
+};
+_defineProperty(UniverRPCMainThreadPlugin, "pluginName", "UNIVER_RPC_MAIN_THREAD_PLUGIN");
+_defineProperty(UniverRPCMainThreadPlugin, "packageName", name);
+_defineProperty(UniverRPCMainThreadPlugin, "version", version);
+UniverRPCMainThreadPlugin = __decorate([__decorateParam(1, Inject(Injector)), __decorateParam(2, IConfigService)], UniverRPCMainThreadPlugin);
+let UniverRPCWorkerThreadPlugin = class UniverRPCWorkerThreadPlugin extends Plugin {
+	constructor(_config = defaultPluginWorkerThreadConfig, _injector, _configService) {
+		super();
+		this._config = _config;
+		this._injector = _injector;
+		this._configService = _configService;
+		const { ...rest } = merge({}, defaultPluginWorkerThreadConfig, this._config);
+		this._configService.setConfig(PLUGIN_CONFIG_KEY_WORKER_THREAD, rest);
+	}
+	onStarting() {
+		[
+			[DataSyncReplicaController],
+			[IRPCChannelService, { useFactory: () => new ChannelService(createWebWorkerMessagePortOnWorker()) }],
+			[IRemoteInstanceService, { useClass: WebWorkerRemoteInstanceService }]
+		].forEach((dependency) => this._injector.add(dependency));
+		this._injector.get(DataSyncReplicaController);
+	}
+};
+_defineProperty(UniverRPCWorkerThreadPlugin, "pluginName", "UNIVER_RPC_WORKER_THREAD_PLUGIN");
+_defineProperty(UniverRPCWorkerThreadPlugin, "packageName", name);
+_defineProperty(UniverRPCWorkerThreadPlugin, "version", version);
+UniverRPCWorkerThreadPlugin = __decorate([__decorateParam(1, Inject(Injector)), __decorateParam(2, IConfigService)], UniverRPCWorkerThreadPlugin);
+
+//#endregion
+export { ChannelClient, ChannelServer, ChannelService, DataSyncPrimaryController, DataSyncReplicaController, IRPCChannelService, IRemoteInstanceService, IRemoteSyncService, PLUGIN_CONFIG_KEY_MAIN_THREAD, PLUGIN_CONFIG_KEY_WORKER_THREAD, RemoteInstanceServiceName, RemoteSyncPrimaryService, RemoteSyncServiceName, UniverRPCMainThreadPlugin, UniverRPCWorkerThreadPlugin, WebWorkerRemoteInstanceService, fromModule, toModule };