redux-tiles
Version:
Library to create and easily compose redux pieces together in less verbose manner
119 lines • 4.75 kB
JavaScript
;
var __assign = (this && this.__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;
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
t[p[i]] = s[p[i]];
return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var helpers_1 = require("../helpers");
function proccessMiddleware(args) {
if (args.length === 3) {
// let's assume it is redux-thunk with extra argument
return __assign({ dispatch: args[0], getState: args[1] }, args[2]);
}
else if (args.length === 2) {
// likely it is redux-thunk
return { dispatch: args[0], getState: args[1] };
}
else if (args.length === 1 && typeof args[0] === 'object') {
// our own middleware
return args[0];
}
// no idea what it is
throw new Error('Redux-Tiles expects own middleware, or redux-thunk');
}
function shouldBeFetched(_a) {
var getState = _a.getState, selectors = _a.selectors, params = _a.params;
var _b = selectors.get(getState(), params), isPending = _b.isPending, data = _b.data, error = _b.error;
// == intentionally to check on empty objects
return error == null && data == null && isPending !== true;
}
function handleMiddleware(fn) {
return function (fnParams, additionalParams) { return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return fn(proccessMiddleware(args), fnParams, additionalParams);
}; };
}
function asyncAction(_a) {
var START = _a.START, SUCCESS = _a.SUCCESS, FAILURE = _a.FAILURE, fn = _a.fn, type = _a.type, caching = _a.caching, nesting = _a.nesting, selectors = _a.selectors;
return handleMiddleware(function (_a, params, _b) {
var forceAsync = (_b === void 0 ? {} : _b).forceAsync;
var dispatch = _a.dispatch, getState = _a.getState, _c = _a.promisesStorage, promisesStorage = _c === void 0 ? {} : _c, middlewares = __rest(_a, ["dispatch", "getState", "promisesStorage"]);
var path = nesting ? nesting(params) : null;
var getIdentificator = helpers_1.createType({ type: type, path: path });
if (caching) {
var activePromise = promisesStorage[getIdentificator];
if (activePromise) {
return activePromise;
}
}
if (caching && !forceAsync) {
var isFetchingNeeded = shouldBeFetched({ getState: getState, selectors: selectors, params: params });
if (!isFetchingNeeded) {
return Promise.resolve();
}
}
dispatch({
type: START,
payload: { path: path }
});
var promise = fn(__assign({ params: params, dispatch: dispatch, getState: getState }, middlewares))
.then(function (data) {
dispatch({
type: SUCCESS,
payload: { path: path, data: data }
});
promisesStorage[getIdentificator] = undefined;
})
.catch(function (error) {
dispatch({
error: error,
type: FAILURE,
payload: { path: path }
});
promisesStorage[getIdentificator] = undefined;
});
promisesStorage[getIdentificator] = promise;
return promise;
});
}
exports.asyncAction = asyncAction;
function createResetAction(_a) {
var type = _a.type;
return handleMiddleware(function (_a) {
var dispatch = _a.dispatch;
return dispatch({ type: type });
});
}
exports.createResetAction = createResetAction;
function syncAction(_a) {
var SET = _a.SET, fn = _a.fn, nesting = _a.nesting;
return handleMiddleware(function (_a, params) {
var dispatch = _a.dispatch, getState = _a.getState, middlewares = __rest(_a, ["dispatch", "getState"]);
var path = nesting ? nesting(params) : null;
return dispatch({
type: SET,
payload: {
path: path,
data: fn(__assign({ params: params, dispatch: dispatch, getState: getState }, middlewares))
}
});
});
}
exports.syncAction = syncAction;
//# sourceMappingURL=actions.js.map