@univerjs/rpc 0.1.0-alpha.1

package/lib/esm/index.js

@@ -0,0 +1,1057 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var _class, _class1;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = function(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) __defProp(target, key, result);
+    return result;
+};
+var __decorateParam = function(index, decorator) {
+    return function(target, key) {
+        return decorator(target, key, index);
+    };
+};
+// src/plugin.ts
+import { Plugin, PluginType } from "@univerjs/core";
+import { createIdentifier as createIdentifier3, Inject, Injector } from "@wendellhu/redi";
+// src/controllers/data-sync/data-sync-primary.controller.ts
+import { CommandType, DocumentType as DocumentType2, ICommandService as ICommandService2, IUniverInstanceService as IUniverInstanceService2, LifecycleStages, OnLifecycle, RxDisposable } from "@univerjs/core";
+import { takeUntil } from "rxjs/operators";
+// src/services/remote-instance/remote-instance.service.ts
+import { DocumentType, ICommandService, IUniverInstanceService } from "@univerjs/core";
+import { createIdentifier } from "@wendellhu/redi";
+var RemoteSyncServiceName = "univer.remote-sync-service";
+var IRemoteSyncService = createIdentifier(RemoteSyncServiceName);
+var RemoteSyncPrimaryService = /*#__PURE__*/ function() {
+    "use strict";
+    function RemoteSyncPrimaryService(_commandService) {
+        _class_call_check(this, RemoteSyncPrimaryService);
+        this._commandService = _commandService;
+    }
+    _create_class(RemoteSyncPrimaryService, [
+        {
+            key: "syncMutation",
+            value: function syncMutation(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this._commandService.syncExecuteCommand(params.mutationInfo.id, params.mutationInfo.params, {
+                                local: true,
+                                fromSync: true
+                            })
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return RemoteSyncPrimaryService;
+}();
+RemoteSyncPrimaryService = __decorateClass([
+    __decorateParam(0, ICommandService)
+], RemoteSyncPrimaryService);
+var RemoteInstanceServiceName = "univer.remote-instance-service";
+var IRemoteInstanceService = createIdentifier(RemoteInstanceServiceName);
+var RemoteInstanceReplicaService = /*#__PURE__*/ function() {
+    "use strict";
+    function RemoteInstanceReplicaService(_univerInstanceService, _commandService) {
+        _class_call_check(this, RemoteInstanceReplicaService);
+        this._univerInstanceService = _univerInstanceService;
+        this._commandService = _commandService;
+    }
+    _create_class(RemoteInstanceReplicaService, [
+        {
+            key: "syncMutation",
+            value: function syncMutation(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this._commandService.syncExecuteCommand(params.mutationInfo.id, params.mutationInfo.params, {
+                                local: true,
+                                fromSync: true
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "createInstance",
+            value: function createInstance(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var type, snapshot;
+                    return _ts_generator(this, function(_state) {
+                        type = params.type, snapshot = params.snapshot;
+                        try {
+                            switch(type){
+                                case DocumentType.SHEET:
+                                    return [
+                                        2,
+                                        !!_this._univerInstanceService.createSheet(snapshot)
+                                    ];
+                                default:
+                                    throw new Error("[RemoteInstanceReplicaService]: cannot create replica for document type: ".concat(type, "."));
+                            }
+                        } catch (err) {
+                            if (_instanceof(err, Error)) {
+                                throw err;
+                            } else {
+                                throw new Error("".concat(err));
+                            }
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "disposeInstance",
+            value: function disposeInstance(params) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            _this._univerInstanceService.disposeDocument(params.unitID)
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return RemoteInstanceReplicaService;
+}();
+RemoteInstanceReplicaService = __decorateClass([
+    __decorateParam(0, IUniverInstanceService),
+    __decorateParam(1, ICommandService)
+], RemoteInstanceReplicaService);
+// src/controllers/data-sync/data-sync-primary.controller.ts
+var DataSyncPrimaryController = /*#__PURE__*/ function(RxDisposable) {
+    "use strict";
+    _inherits(DataSyncPrimaryController, RxDisposable);
+    var _super = _create_super(DataSyncPrimaryController);
+    function DataSyncPrimaryController(_unsyncMutations, _univerInstanceService, _remoteInstanceService, _commandService) {
+        _class_call_check(this, DataSyncPrimaryController);
+        var _this;
+        _this = _super.call(this);
+        _this._unsyncMutations = _unsyncMutations;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._remoteInstanceService = _remoteInstanceService;
+        _this._commandService = _commandService;
+        _this._init();
+        return _this;
+    }
+    _create_class(DataSyncPrimaryController, [
+        {
+            key: "_init",
+            value: function _init() {
+                var _this = this;
+                this._univerInstanceService.sheetAdded$.pipe(takeUntil(this.dispose$)).subscribe(function(sheet) {
+                    _this._remoteInstanceService.createInstance({
+                        unitID: sheet.getUnitId(),
+                        type: DocumentType2.SHEET,
+                        snapshot: sheet.getSnapshot()
+                    });
+                });
+                this._univerInstanceService.sheetDisposed$.pipe(takeUntil(this.dispose$)).subscribe(function(workbook) {
+                    _this._remoteInstanceService.disposeInstance({
+                        unitID: workbook.getUnitId()
+                    });
+                });
+                this.disposeWithMe(// Mutations executed on the main thread should be synced to the worker thread.
+                this._commandService.onCommandExecuted(function(commandInfo, options) {
+                    if (commandInfo.type === CommandType.MUTATION && !(options === null || options === void 0 ? void 0 : options.fromSync) && !_this._unsyncMutations.has(commandInfo.id)) {
+                        _this._remoteInstanceService.syncMutation({
+                            mutationInfo: commandInfo
+                        });
+                    }
+                }));
+            }
+        }
+    ]);
+    return DataSyncPrimaryController;
+}(RxDisposable);
+DataSyncPrimaryController = __decorateClass([
+    OnLifecycle(LifecycleStages.Starting, DataSyncPrimaryController),
+    __decorateParam(1, IUniverInstanceService2),
+    __decorateParam(2, IRemoteInstanceService),
+    __decorateParam(3, ICommandService2)
+], DataSyncPrimaryController);
+// src/controllers/data-sync/data-sync-replica.controller.ts
+import { CommandType as CommandType2, Disposable, ICommandService as ICommandService3, IUniverInstanceService as IUniverInstanceService3, LifecycleStages as LifecycleStages2, OnLifecycle as OnLifecycle2 } from "@univerjs/core";
+var DataSyncReplicaController = /*#__PURE__*/ function(Disposable) {
+    "use strict";
+    _inherits(DataSyncReplicaController, Disposable);
+    var _super = _create_super(DataSyncReplicaController);
+    function DataSyncReplicaController(_commandService, _remoteInstanceService, _univerInstanceService) {
+        _class_call_check(this, DataSyncReplicaController);
+        var _this;
+        _this = _super.call(this);
+        _this._commandService = _commandService;
+        _this._remoteInstanceService = _remoteInstanceService;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._init();
+        return _this;
+    }
+    _create_class(DataSyncReplicaController, [
+        {
+            key: "_init",
+            value: function _init() {
+                var _this = this;
+                this.disposeWithMe(// Mutations executed on the main thread should be synced to the worker thread.
+                this._commandService.onCommandExecuted(function(commandInfo, options) {
+                    if (commandInfo.type === CommandType2.MUTATION && !(options === null || options === void 0 ? void 0 : options.fromSync)) {
+                        _this._remoteInstanceService.syncMutation({
+                            mutationInfo: commandInfo
+                        });
+                    }
+                }));
+            }
+        }
+    ]);
+    return DataSyncReplicaController;
+}(Disposable);
+DataSyncReplicaController = __decorateClass([
+    OnLifecycle2(LifecycleStages2.Starting, DataSyncReplicaController),
+    __decorateParam(0, ICommandService3),
+    __decorateParam(1, IRemoteSyncService),
+    __decorateParam(2, IUniverInstanceService3)
+], DataSyncReplicaController);
+// src/services/implementations/web-worker-rpc.service.ts
+import { Observable, shareReplay } from "rxjs";
+function createWebWorkerMessagePortOnWorker() {
+    return {
+        send: function send(message) {
+            postMessage(message);
+        },
+        onMessage: new Observable(function(subscriber) {
+            var handler = function(event) {
+                subscriber.next(event.data);
+            };
+            addEventListener("message", handler);
+            return function() {
+                return removeEventListener("message", handler);
+            };
+        }).pipe(shareReplay(1))
+    };
+}
+function createWebWorkerMessagePortOnMain(worker) {
+    return {
+        send: function send(message) {
+            worker.postMessage(message);
+        },
+        onMessage: new Observable(function(subscriber) {
+            var handler = function(event) {
+                subscriber.next(event.data);
+            };
+            worker.addEventListener("message", handler);
+            return function() {
+                return worker.removeEventListener("message", handler);
+            };
+        }).pipe(shareReplay(1))
+    };
+}
+// src/services/rpc/rpc.service.ts
+import { RxDisposable as RxDisposable2 } from "@univerjs/core";
+import { createIdentifier as createIdentifier2 } from "@wendellhu/redi";
+import { BehaviorSubject, firstValueFrom, isObservable, Observable as Observable2, of } from "rxjs";
+import { filter, take, takeUntil as takeUntil2 } from "rxjs/operators";
+function fromModule(module) {
+    var handler = module;
+    return new /*#__PURE__*/ (function() {
+        "use strict";
+        function _class() {
+            _class_call_check(this, _class);
+        }
+        _create_class(_class, [
+            {
+                key: "call",
+                value: function call(method, args) {
+                    var target = handler[method];
+                    if (typeof target === "function") {
+                        var res = target.apply(handler, [
+                            args
+                        ]);
+                        if (!_instanceof(res, Promise)) {
+                            res = Promise.resolve(res);
+                        }
+                        return res;
+                    }
+                    throw new Error("[RPC]: method not found for ".concat(method, "!"));
+                }
+            },
+            {
+                key: "subscribe",
+                value: function subscribe(eventMethod, args) {
+                    var target = handler[eventMethod];
+                    if (typeof target === "function") {
+                        var res = target.apply(handler, args);
+                        if (!isObservable(res)) {
+                            return of(res);
+                        }
+                        return res;
+                    }
+                    throw new Error("[RPC]: observable method not found for ".concat(eventMethod, "!"));
+                }
+            }
+        ]);
+        return _class;
+    }())();
+}
+function toModule(channel) {
+    return new Proxy({}, {
+        get: function get(_, propKey) {
+            return function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                var isObservable2 = propertyIsEventSource(propKey);
+                if (isObservable2) {
+                    var observable = channel.subscribe(propKey, args[0]);
+                    return observable;
+                }
+                return channel.call(propKey, args[0]);
+            };
+        }
+    });
+}
+function propertyIsEventSource(name) {
+    return name.endsWith("$");
+}
+var ChannelClient = /*#__PURE__*/ function(RxDisposable2) {
+    "use strict";
+    _inherits(ChannelClient, RxDisposable2);
+    var _super = _create_super(ChannelClient);
+    function ChannelClient(_protocol) {
+        _class_call_check(this, ChannelClient);
+        var _this;
+        _this = _super.call(this);
+        _define_property(_assert_this_initialized(_this), "_initialized", new BehaviorSubject(false));
+        _define_property(_assert_this_initialized(_this), "_lastRequestCounter", 0);
+        _define_property(_assert_this_initialized(_this), "_pendingRequests", /* @__PURE__ */ new Map());
+        _define_property(_assert_this_initialized(_this), "_pendingSubscriptions", /* @__PURE__ */ new Map());
+        _this._protocol = _protocol;
+        _this._protocol.onMessage.pipe(takeUntil2(_this.dispose$)).subscribe(function(message) {
+            return _this._onResponse(message);
+        });
+        return _this;
+    }
+    _create_class(ChannelClient, [
+        {
+            key: "getChannel",
+            value: function getChannel(channelName) {
+                var self = this;
+                return {
+                    call: function call(method, args) {
+                        if (self._disposed) {
+                            return Promise.reject();
+                        }
+                        return self._remoteCall(channelName, method, args);
+                    },
+                    subscribe: function subscribe(eventMethod, args) {
+                        if (self._disposed) {
+                            throw new Error("[ChannelClient]: client is disposed!");
+                        }
+                        return self._remoteSubscribe(channelName, eventMethod, args);
+                    }
+                };
+            }
+        },
+        {
+            key: "_whenReady",
+            value: function _whenReady() {
+                return firstValueFrom(this._initialized.pipe(filter(function(v) {
+                    return v;
+                }), take(1)));
+            }
+        },
+        {
+            key: "_remoteCall",
+            value: function _remoteCall(channelName, method, args) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var sequence, type, request, client;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    _this._whenReady()
+                                ];
+                            case 1:
+                                _state.sent();
+                                sequence = ++_this._lastRequestCounter;
+                                type = 100 /* CALL */ ;
+                                request = {
+                                    seq: sequence,
+                                    type: type,
+                                    channelName: channelName,
+                                    method: method,
+                                    args: args
+                                };
+                                client = _this;
+                                return [
+                                    2,
+                                    new Promise(function(resolve, reject) {
+                                        var responseHandler = {
+                                            handle: function handle(response) {
+                                                switch(response.type){
+                                                    case 100 /* CALL_SUCCESS */ :
+                                                        client._pendingRequests.delete(sequence);
+                                                        resolve(response.data);
+                                                        break;
+                                                    case 101 /* CALL_FAILURE */ :
+                                                        client._pendingRequests.delete(sequence);
+                                                        reject(response.data);
+                                                        break;
+                                                    default:
+                                                        throw new Error("[ChannelClient]: unknown response type!");
+                                                }
+                                            }
+                                        };
+                                        _this._pendingRequests.set(sequence, responseHandler);
+                                        _this._sendRequest(request);
+                                    })
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_remoteSubscribe",
+            value: function _remoteSubscribe(channelName, method, args) {
+                var _this = this;
+                return new Observable2(function(subscriber) {
+                    var sequence = -1;
+                    _this._whenReady().then(function() {
+                        sequence = ++_this._lastRequestCounter;
+                        var type = 101 /* SUBSCRIBE */ ;
+                        var request = {
+                            seq: sequence,
+                            type: type,
+                            channelName: channelName,
+                            method: method,
+                            args: args
+                        };
+                        var responseHandler = {
+                            handle: function handle(response) {
+                                switch(response.type){
+                                    case 200 /* SUBSCRIBE_NEXT */ :
+                                        subscriber.next(response.data);
+                                        break;
+                                    case 201 /* SUBSCRIBE_ERROR */ :
+                                        subscriber.error(response.data);
+                                        break;
+                                    case 202 /* SUBSCRIBE_COMPLETE */ :
+                                        subscriber.complete();
+                                        break;
+                                    default:
+                                        throw new Error("[ChannelClient]: unknown response type!");
+                                }
+                            }
+                        };
+                        _this._pendingRequests.set(sequence, responseHandler);
+                        _this._sendRequest(request);
+                    });
+                    return function() {
+                        if (sequence === -1) {
+                            return;
+                        }
+                        var cancelSubscriptionRequest = {
+                            type: 102 /* UNSUBSCRIBE */ ,
+                            seq: sequence,
+                            channelName: channelName,
+                            method: method
+                        };
+                        _this._sendRequest(cancelSubscriptionRequest);
+                    };
+                });
+            }
+        },
+        {
+            key: "_sendRequest",
+            value: function _sendRequest(request) {
+                this._protocol.send(request);
+            }
+        },
+        {
+            key: "_onResponse",
+            value: function _onResponse(response) {
+                switch(response.type){
+                    case 0 /* INITIALIZE */ :
+                        this._initialized.next(true);
+                        break;
+                    case 100 /* CALL_SUCCESS */ :
+                    case 101 /* CALL_FAILURE */ :
+                    case 200 /* SUBSCRIBE_NEXT */ :
+                    case 202 /* SUBSCRIBE_COMPLETE */ :
+                    case 201 /* SUBSCRIBE_ERROR */ :
+                        var _this__pendingRequests_get;
+                        (_this__pendingRequests_get = this._pendingRequests.get(response.seq)) === null || _this__pendingRequests_get === void 0 ? void 0 : _this__pendingRequests_get.handle(response);
+                        break;
+                }
+            }
+        }
+    ]);
+    return ChannelClient;
+}(RxDisposable2);
+var ChannelServer = /*#__PURE__*/ function(RxDisposable2) {
+    "use strict";
+    _inherits(ChannelServer, RxDisposable2);
+    var _super = _create_super(ChannelServer);
+    function ChannelServer(_protocol) {
+        _class_call_check(this, ChannelServer);
+        var _this;
+        _this = _super.call(this);
+        _define_property(_assert_this_initialized(_this), "_channels", /* @__PURE__ */ new Map());
+        _define_property(_assert_this_initialized(_this), "_subscriptions", /* @__PURE__ */ new Map());
+        _this._protocol = _protocol;
+        _this._protocol.onMessage.pipe(takeUntil2(_this.dispose$)).subscribe(function(message) {
+            return _this._onRequest(message);
+        });
+        _this._sendResponse({
+            seq: -1,
+            type: 0 /* INITIALIZE */ 
+        });
+        return _this;
+    }
+    _create_class(ChannelServer, [
+        {
+            key: "registerChannel",
+            value: function registerChannel(channelName, channel) {
+                this._channels.set(channelName, channel);
+            }
+        },
+        {
+            key: "_onRequest",
+            value: function _onRequest(request) {
+                switch(request.type){
+                    case 100 /* CALL */ :
+                        this._onMethodCall(request);
+                        break;
+                    case 101 /* SUBSCRIBE */ :
+                        this._onSubscribe(request);
+                        break;
+                    case 102 /* UNSUBSCRIBE */ :
+                        this._onUnsubscribe(request);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        },
+        {
+            key: "_onMethodCall",
+            value: function _onMethodCall(request) {
+                var _this = this;
+                var channel = this._channels.get(request.channelName);
+                var promise;
+                try {
+                    if (!channel) {
+                        throw new Error("[ChannelServer]: Channel not found!");
+                    }
+                    promise = channel.call(request.method, request.args);
+                } catch (err) {
+                    promise = Promise.reject(err);
+                }
+                promise.then(function(data) {
+                    _this._sendResponse({
+                        seq: request.seq,
+                        type: 100 /* CALL_SUCCESS */ ,
+                        data: data
+                    });
+                }).catch(function(err) {
+                    if (_instanceof(err, Error)) {
+                        _this._sendResponse({
+                            seq: request.seq,
+                            type: 101 /* CALL_FAILURE */ ,
+                            data: err.message
+                        });
+                    } else {
+                        _this._sendResponse({
+                            seq: request.seq,
+                            type: 101 /* CALL_FAILURE */ ,
+                            data: String(err)
+                        });
+                    }
+                });
+            }
+        },
+        {
+            key: "_onSubscribe",
+            value: function _onSubscribe(request) {
+                var _this = this;
+                var channel = this._channels.get(request.channelName);
+                try {
+                    if (!channel) {
+                        throw new Error("[ChannelServer]: Channel not found!");
+                    }
+                    var observable = channel.subscribe(request.method, request.args);
+                    var subscription = observable.subscribe({
+                        next: function(data) {
+                            _this._sendResponse({
+                                seq: request.seq,
+                                type: 200 /* SUBSCRIBE_NEXT */ ,
+                                data: data
+                            });
+                        },
+                        error: function(err) {
+                            _this._sendResponse({
+                                seq: request.seq,
+                                type: 201 /* SUBSCRIBE_ERROR */ ,
+                                data: err.message
+                            });
+                            _this._sendResponse({
+                                seq: request.seq,
+                                type: 202 /* SUBSCRIBE_COMPLETE */ 
+                            });
+                        },
+                        complete: function() {
+                            _this._sendResponse({
+                                seq: request.seq,
+                                type: 202 /* SUBSCRIBE_COMPLETE */ 
+                            });
+                        }
+                    });
+                    this._subscriptions.set(request.seq, subscription);
+                } catch (err) {
+                    if (_instanceof(err, Error)) {
+                        this._sendResponse({
+                            seq: request.seq,
+                            type: 201 /* SUBSCRIBE_ERROR */ ,
+                            data: err.message
+                        });
+                    } else {
+                        this._sendResponse({
+                            seq: request.seq,
+                            type: 201 /* SUBSCRIBE_ERROR */ ,
+                            data: String(err)
+                        });
+                    }
+                }
+            }
+        },
+        {
+            key: "_onUnsubscribe",
+            value: function _onUnsubscribe(request) {
+                var subscription = this._subscriptions.get(request.seq);
+                if (subscription) {
+                    subscription.unsubscribe();
+                    this._subscriptions.delete(request.seq);
+                }
+            }
+        },
+        {
+            key: "_sendResponse",
+            value: function _sendResponse(response) {
+                this._protocol.send(response);
+            }
+        }
+    ]);
+    return ChannelServer;
+}(RxDisposable2);
+var IRPCService = createIdentifier2("IRPCService");
+// src/plugin.ts
+var ITestService = createIdentifier3("ITestService");
+var UniverRPCMainThreadPlugin = (_class = /*#__PURE__*/ function(Plugin) {
+    "use strict";
+    _inherits(_class, Plugin);
+    var _super = _create_super(_class);
+    function _class(_config, _injector) {
+        _class_call_check(this, _class);
+        var _this;
+        _this = _super.call(this, "UNIVER_RPC_MAIN_THREAD_PLUGIN");
+        _this._config = _config;
+        _this._injector = _injector;
+        return _this;
+    }
+    _create_class(_class, [
+        {
+            key: "onStarting",
+            value: function onStarting(injector) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var worker, messageProtocol, client, server, dependencies;
+                    return _ts_generator(this, function(_state) {
+                        worker = new Worker(_this._config.workerURL);
+                        messageProtocol = createWebWorkerMessagePortOnMain(worker);
+                        client = new ChannelClient(messageProtocol);
+                        server = new ChannelServer(messageProtocol);
+                        dependencies = [
+                            [
+                                DataSyncPrimaryController,
+                                {
+                                    useFactory: function() {
+                                        var _this__config;
+                                        var _this__config_unsyncMutations;
+                                        return injector.createInstance(DataSyncPrimaryController, (_this__config_unsyncMutations = (_this__config = _this._config) === null || _this__config === void 0 ? void 0 : _this__config.unsyncMutations) !== null && _this__config_unsyncMutations !== void 0 ? _this__config_unsyncMutations : /* @__PURE__ */ new Set());
+                                    }
+                                }
+                            ],
+                            [
+                                IRemoteInstanceService,
+                                {
+                                    useFactory: function() {
+                                        return toModule(client.getChannel(RemoteInstanceServiceName));
+                                    }
+                                }
+                            ],
+                            [
+                                IRemoteSyncService,
+                                {
+                                    useClass: RemoteSyncPrimaryService
+                                }
+                            ]
+                        ];
+                        dependencies.forEach(function(dependency) {
+                            return injector.add(dependency);
+                        });
+                        server.registerChannel(RemoteSyncServiceName, fromModule(injector.get(IRemoteSyncService)));
+                        return [
+                            2
+                        ];
+                    });
+                })();
+            }
+        }
+    ]);
+    return _class;
+}(_wrap_native_super(Plugin)), _define_property(_class, "type", PluginType.Univer), _class);
+UniverRPCMainThreadPlugin = __decorateClass([
+    __decorateParam(1, Inject(Injector))
+], UniverRPCMainThreadPlugin);
+var UniverRPCWorkerThreadPlugin = (_class1 = /*#__PURE__*/ function(Plugin) {
+    "use strict";
+    _inherits(_class, Plugin);
+    var _super = _create_super(_class);
+    function _class(_config, _injector) {
+        _class_call_check(this, _class);
+        var _this;
+        _this = _super.call(this, "UNIVER_RPC_WORKER_THREAD_PLUGIN");
+        _this._config = _config;
+        _this._injector = _injector;
+        return _this;
+    }
+    _create_class(_class, [
+        {
+            key: "onStarting",
+            value: function onStarting(injector) {
+                var messageProtocol = createWebWorkerMessagePortOnWorker();
+                var client = new ChannelClient(messageProtocol);
+                var server = new ChannelServer(messageProtocol);
+                var dependencies = [
+                    [
+                        DataSyncReplicaController
+                    ],
+                    [
+                        IRemoteSyncService,
+                        {
+                            useFactory: function() {
+                                return toModule(client.getChannel(RemoteSyncServiceName));
+                            }
+                        }
+                    ],
+                    [
+                        IRemoteInstanceService,
+                        {
+                            useClass: RemoteInstanceReplicaService
+                        }
+                    ]
+                ];
+                dependencies.forEach(function(dependency) {
+                    return injector.add(dependency);
+                });
+                server.registerChannel(RemoteInstanceServiceName, fromModule(injector.get(IRemoteInstanceService)));
+            }
+        }
+    ]);
+    return _class;
+}(_wrap_native_super(Plugin)), _define_property(_class1, "type", PluginType.Univer), _class1);
+UniverRPCWorkerThreadPlugin = __decorateClass([
+    __decorateParam(1, Inject(Injector))
+], UniverRPCWorkerThreadPlugin);
+export { UniverRPCMainThreadPlugin, UniverRPCWorkerThreadPlugin };