electron-event-flux
Version:
Redux store which synchronizes between instances in multiple process
239 lines (238 loc) • 11.6 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
Object.defineProperty(exports, "__esModule", { value: true });
var AppStore_1 = require("./AppStore");
var objectDifference_1 = require("./utils/objectDifference");
var filterDifference_1 = require("./utils/filterDifference");
var filterApply_1 = require("./utils/filterApply");
var filterStore_1 = require("./utils/filterStore");
var filterWindowStore_1 = require("./utils/filterWindowStore");
var StoreDeclarer_1 = require("./StoreDeclarer");
var MainClient_1 = require("./MainClient");
var MultiWinManagerStore_1 = require("./MultiWinManagerStore");
var ActionRecordStore_1 = require("./ActionRecordStore");
var MultiWinStore_1 = require("./MultiWinStore");
var stateFilterDecorator_1 = require("./utils/stateFilterDecorator");
var loggerApply_1 = require("./utils/loggerApply");
var objUtils_1 = require("./utils/objUtils");
var constants_1 = require("./constants");
var json_immutable_bn_1 = require("json-immutable-bn");
function findStore(stores, storePath) {
if (!storePath)
return;
return storePath.reduce(function (subStores, entry) {
if (!subStores)
return undefined;
if (!objUtils_1.isObject(entry))
return subStores[entry];
var _a = entry, name = _a.name, type = _a.type, index = _a.index;
var storeCol = subStores[name];
if (type === 'List' || type === 'Map') {
return storeCol.get(index);
}
}, stores);
}
function storeEnhancer(appStore, stores, storeShape, log) {
var callbacks = {
addWin: function (clientId) {
stores[constants_1.winManagerStoreName].addWin(clientId);
},
deleteWin: function (clientId) {
stores[constants_1.winManagerStoreName].deleteWin(clientId);
},
getStores: function (clientId) {
var stores = filterWindowStore_1.filterWindowStore(storeShape, constants_1.winManagerStoreName, clientId);
return JSON.stringify(stores);
},
getInitStates: function (clientId) {
if (process.env.NODE_ENV === 'development') {
if (!appStore._prevStateFilters || !appStore._prevStateFilters[clientId]) {
console.error('The filter should has init, If not, then should has a bug!');
}
if (appStore._prevStateFilters !== appStore._stateFilters) {
console.error('The state filters should has update before get initial states!');
}
if (appStore.prevState !== appStore.state) {
console.error('The state should has updated before get initial states!');
}
}
var updateState = filterApply_1.default(appStore.prevState, appStore._prevStateFilters[clientId], null);
var filterState = filterWindowStore_1.filterWindowState(updateState, constants_1.winManagerKey, clientId);
return json_immutable_bn_1.serialize(filterState);
},
handleRendererMessage: function (payload) {
try {
var _a = json_immutable_bn_1.deserialize(payload), storePath = _a.store, method = _a.method, args = _a.args;
var store = findStore(stores, storePath);
if (!store) {
throw new Error("The store for method " + method + " is not defined");
}
if (!store[method]) {
throw new Error("The method " + method + " in Store " + store + " is not defined");
}
var result = store[method].apply(store, args);
return Promise.resolve(result);
}
catch (err) {
appStore.onHandleErr(err);
return Promise.reject(err);
}
}
};
var mainClient = new MainClient_1.default(callbacks, log);
appStore.mainClient = mainClient;
var forwarder = function (prevState, state, prevFilters, filters) {
// Forward all actions to the listening renderers
var clientInfo = mainClient.getForwardClients();
if (clientInfo.length === 0)
return;
clientInfo.forEach(function (client) {
var clientId = client.clientId;
if (prevFilters[clientId] !== filters[clientId]) {
var _a = filterDifference_1.default(prevFilters[clientId], filters[clientId]), updated = _a.updated, deleted = _a.deleted;
var updateState = filterApply_1.default(state, updated, deleted);
updateState = filterWindowStore_1.filterWindowState(updateState, constants_1.winManagerKey, clientId);
if (objUtils_1.isEmpty(updateState))
return;
mainClient.dispatchToRenderer(client, json_immutable_bn_1.serialize({ payload: { updated: updateState } }));
}
});
var delta = objectDifference_1.default(prevState, state);
if (objUtils_1.isEmpty(delta.updated) && objUtils_1.isEmpty(delta.deleted))
return;
clientInfo.forEach(function (client) {
var clientId = client.clientId;
var filterUpdated = filterApply_1.default(delta.updated, filters[clientId], null);
var filterDeleted = filterApply_1.default(delta.deleted, filters[clientId], null);
var _a = __read(filterWindowStore_1.filterWindowDelta(filterUpdated, filterDeleted, constants_1.winManagerKey, clientId), 2), updated = _a[0], deleted = _a[1];
if (objUtils_1.isEmpty(updated) && objUtils_1.isEmpty(deleted)) {
return;
}
var action = { payload: { updated: updated, deleted: deleted } };
mainClient.dispatchToRenderer(client, json_immutable_bn_1.serialize(action));
});
};
return forwarder;
}
var MultiWindowAppStore = /** @class */ (function (_super) {
__extends(MultiWindowAppStore, _super);
function MultiWindowAppStore(log) {
var _this = _super.call(this) || this;
_this.filterCallbacks = [];
_this.log = log;
return _this;
}
MultiWindowAppStore.prototype.init = function () {
var _this = this;
this.buildStores();
this.initStores(this);
this._initStateFilters();
var winManagerStore = this.stores.winManagerStore;
winManagerStore.onDidAddWin(function (clientId) {
_this._handleAddWin(clientId);
_this._sendUpdate();
});
winManagerStore.onDidRemoveWin(function (clientId) { return _this._handleRemoveWin(clientId); });
this._prevStateFilters = Object.assign({}, this._stateFilters);
this.startObserve();
_super.prototype.init.call(this);
this.forwarder = storeEnhancer(this, this.stores, this.storeShape, this.log);
return this;
};
MultiWindowAppStore.prototype.handleWillFilterChange = function (prevState, state, prevFilters, filters) {
return this.forwarder(prevState, state, prevFilters, filters);
};
;
MultiWindowAppStore.prototype.onDidFilterChange = function (callback) {
this.filterCallbacks.push(callback);
};
MultiWindowAppStore.prototype.handleFilterChange = function () {
this.batchUpdater.requestUpdate();
};
MultiWindowAppStore.prototype._sendUpdate = function () {
var _this = this;
this.handleWillFilterChange(this.prevState, this.state, this._prevStateFilters, this._stateFilters);
this.didChangeCallbacks.forEach(function (callback) { return callback(_this.state); });
this.prevState = this.state;
this.filterCallbacks.forEach(function (callback) { return callback(_this._stateFilters); });
this._prevStateFilters = Object.assign({}, this._stateFilters);
};
MultiWindowAppStore.prototype.getStore = function (key) {
return this.stores[key];
};
MultiWindowAppStore.prototype.setStore = function (key, store) {
return this.stores[key] = store;
};
MultiWindowAppStore.prototype.getStores = function () {
return this.stores;
};
MultiWindowAppStore.prototype.getWinSpecificStore = function (clientId, storeName) {
var winStores = this.stores[constants_1.winManagerStoreName].winPackMap[clientId];
if (winStores)
return winStores[storeName];
};
MultiWindowAppStore.prototype.onHandleErr = function (err) { };
// 构建子Stores
MultiWindowAppStore.prototype.buildStores = function () { };
// 初始化子Stores
MultiWindowAppStore.prototype.initStores = function (parent) { };
// 开始监听子Store改变
MultiWindowAppStore.prototype.startObserve = function () { };
MultiWindowAppStore.prototype._initStateFilters = function () { };
MultiWindowAppStore.prototype._handleAddWin = function (clientId) { };
MultiWindowAppStore.prototype._handleRemoveWin = function (clientId) { };
return MultiWindowAppStore;
}(AppStore_1.default));
function buildMultiWinAppStore(stores, winStores, _a, logger) {
var _b;
var _c = _a.WindowsManagerStore, WindowsManagerStore = _c === void 0 ? MultiWinManagerStore_1.default : _c, _d = _a.ActionStore, ActionStore = _d === void 0 ? ActionRecordStore_1.default : _d, _e = _a.WinHandleStore, WinHandleStore = _e === void 0 ? MultiWinStore_1.default : _e;
MultiWinManagerStore_1.WinPackStore.innerStores = __assign({}, winStores, { actionRecord: ActionStore });
var allStores = __assign({}, stores, (_b = { multiWin: WinHandleStore }, _b[constants_1.winManagerKey] = StoreDeclarer_1.declareStore(WindowsManagerStore, { storeKey: constants_1.winManagerStoreName }), _b));
var MultiWinAppStore = stateFilterDecorator_1.default(MultiWindowAppStore);
MultiWinAppStore.innerStores = allStores;
var storeShape = filterStore_1.filterOneStore(MultiWinAppStore, { applyFilter: true });
var appStore = new MultiWinAppStore(loggerApply_1.default(logger));
appStore.storeShape = storeShape;
appStore.init();
return appStore;
}
exports.default = buildMultiWinAppStore;