reactant-share/dist/esm/client.js

A framework for building shared web applications with Reactant

import { __awaiter, __generator, __assign, __rest, __values } from './node_modules/tslib/tslib.es6.js';
import { containerKey, actionIdentifier, applyPatches } from 'reactant';
import { LastAction } from 'reactant-last-action';
import { lastActionName, proxyServerActionName } from './constants.js';
import { PortDetector } from './modules/portDetector.js';
import { applyMethod } from './applyMethod.js';

var handleClient = function (_a) {
    var app = _a.app, transport = _a.transport, disposeServer = _a.disposeServer, disposeClient = _a.disposeClient, enablePatchesFilter = _a.enablePatchesFilter, preloadedState = _a.preloadedState;
    if (!transport) {
        throw new Error("The client transport does not exist.");
    }
    disposeServer === null || disposeServer === void 0 ? void 0 : disposeServer();
    disposeClient === null || disposeClient === void 0 ? void 0 : disposeClient();
    var container = app.instance[containerKey];
    var lastAction = container.get(LastAction);
    var portDetector = container.get(PortDetector);
    portDetector.setPort({ client: app }, transport);
    var disposeListeners = [];
    if (preloadedState) {
        lastAction.sequence = preloadedState[lastAction.stateKey]._sequence;
    }
    disposeListeners.push(transport.listen(lastActionName, function (action) { return __awaiter(void 0, void 0, void 0, function () {
        var currentState_1, _patches, patches, state;
        var _a;
        return __generator(this, function (_b) {
            if (portDetector.disableSyncClient)
                return [2 /*return*/];
            if (action._sequence && action._sequence === lastAction.sequence + 1) {
                if (action._reactant === actionIdentifier) {
                    currentState_1 = app.store.getState();
                    _patches = (_a = action._patches) !== null && _a !== void 0 ? _a : [];
                    patches = enablePatchesFilter
                        ? _patches.filter(function (item) { return currentState_1[item.path[0]]; })
                        : _patches;
                    state = applyPatches(currentState_1, patches);
                    app.store.dispatch(__assign(__assign({}, action), { state: state }));
                }
                else {
                    app.store.dispatch(action);
                }
                lastAction.sequence = action._sequence;
            }
            else {
                portDetector.syncFullState({ forceSync: false });
            }
            return [2 /*return*/];
        });
    }); }));
    disposeListeners.push(transport.listen(proxyServerActionName, function (_a) { return __awaiter(void 0, void 0, void 0, function () {
        var result;
        var clientIds = _a.clientIds, portName = _a.portName, options = __rest(_a, ["clientIds", "portName"]);
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    // ignore non-specified id or name of client
                    if ((Array.isArray(clientIds) &&
                        portDetector.clientId &&
                        !clientIds.includes(portDetector.clientId)) ||
                        (portName && portName !== portDetector.name))
                        return [2 /*return*/, new Promise(function () {
                                // never resolve
                            })];
                    return [4 /*yield*/, applyMethod(app, options)];
                case 1:
                    result = _b.sent();
                    return [2 /*return*/, result];
            }
        });
    }); }));
    disposeListeners.push(function () { return transport.dispose(); });
    return function () {
        var e_1, _a;
        try {
            for (var disposeListeners_1 = __values(disposeListeners), disposeListeners_1_1 = disposeListeners_1.next(); !disposeListeners_1_1.done; disposeListeners_1_1 = disposeListeners_1.next()) {
                var dispose = disposeListeners_1_1.value;
                dispose === null || dispose === void 0 ? void 0 : dispose();
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (disposeListeners_1_1 && !disposeListeners_1_1.done && (_a = disposeListeners_1.return)) _a.call(disposeListeners_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
    };
};

export { handleClient };