redux-tiles
Version:
Library to create and easily compose redux pieces together in less verbose manner
147 lines • 5.56 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 isPending = _a.isPending, fetched = _a.fetched, error = _a.error;
// if it is pending, then we have to wait anyway
if (isPending) {
return false;
}
// in case it was not fetched yet, we have to fetch it for the first time
if (fetched === false) {
return true;
}
// and if error is not null or undefined, we have to re-fetch it again
if (error != null) {
return true;
}
return false;
}
exports.shouldBeFetched = shouldBeFetched;
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 _d = selectors.get(getState(), params), isPending = _d.isPending, fetched = _d.fetched, error = _d.error, data = _d.data;
var isFetchingNeeded = shouldBeFetched({
isPending: isPending,
fetched: fetched,
error: error
});
if (!isFetchingNeeded) {
return Promise.resolve({ data: data, error: error, isPending: isPending });
}
}
dispatch({
type: START,
payload: { path: path },
isPending: true
});
var promise = fn(__assign({ params: params,
dispatch: dispatch,
getState: getState }, middlewares))
.then(function (data) {
promisesStorage[getIdentificator] = undefined;
return dispatch({
type: SUCCESS,
payload: { path: path, data: data },
data: data,
isPending: false
});
})
.catch(function (error) {
promisesStorage[getIdentificator] = undefined;
return dispatch({
error: error,
type: FAILURE,
payload: { path: path },
isPending: false
});
});
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, selector = _a.selector;
return handleMiddleware(function (_a, params) {
var dispatch = _a.dispatch, getState = _a.getState, middlewares = __rest(_a, ["dispatch", "getState"]);
var path = nesting ? nesting(params) : null;
var getData = function () { return selector(getState(), params); };
var data = fn(__assign({ params: params,
dispatch: dispatch,
getState: getState,
getData: getData }, middlewares));
return dispatch({
type: SET,
payload: {
path: path,
data: data
},
data: data
});
});
}
exports.syncAction = syncAction;
//# sourceMappingURL=actions.js.map