clean-redux/middlewareEvtAction.js

Utilities for implementing clean architecture using Redux

"use strict";
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;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createMiddlewareEvtActionFactory = void 0;
var evt_1 = require("evt");
var exclude_1 = require("tsafe/exclude");
var typeGuard_1 = require("tsafe/typeGuard");
var symToStr_1 = require("tsafe/symToStr");
/*
type RecordToUnion<O> = O[keyof O];

type CaseReducerToEvent<T extends Record<string, ActionCreator<any>>> = RecordToUnion<{
    [K in keyof T]: { actionName: K } & (T[K] extends ActionCreatorWithoutPayload<any>
        ? {}
        : {
              payload: T[K] extends ActionCreatorWithPayload<infer U> ? U : never;
          });
}>;

type UsecaseToEvent<
    Usecase extends { name: string } & (
        | { actions: Record<string, ActionCreator<any>> }
        | { reducer: null }
    ),
> = RecordToUnion<{
    [Key in Extract<Usecase, { actions: unknown }>["name"]]: Usecase extends Extract<
        Usecase,
        { name: Key; actions: unknown }
    >
        ? { sliceName: Key } & CaseReducerToEvent<Usecase["actions"]>
        : never;
}>;
*/
function createMiddlewareEvtActionFactory(usecases) {
    function createMiddlewareEvtAction() {
        var actionTypes = new Set(usecases
            .map(function (usecase) {
            return (0, typeGuard_1.typeGuard)(usecase, "reducer" in usecase && usecase.reducer !== null)
                ? usecase
                : undefined;
        })
            .filter((0, exclude_1.exclude)(undefined))
            .map(function (_a) {
            var name = _a.name, actions = _a.actions;
            return Object.keys(actions).map(function (actionName) { return "".concat(name, "/").concat(actionName); });
        })
            .reduce(function (prev, curr) { return __spreadArray(__spreadArray([], __read(prev), false), __read(curr), false); }, []));
        var evtAction = evt_1.Evt.create();
        var middlewareEvtAction = function () { return function (next) { return function (action) {
            if (!actionTypes.has(action.type) &&
                !["pending", "rejected", "fulfilled"].find(function (lifecycleStage) {
                    return action.type.endsWith("/".concat(lifecycleStage));
                })) {
                console.warn([
                    "Unknown action type ".concat(action.type, "."),
                    "".concat((0, symToStr_1.symToStr)({ middlewareEvtAction: middlewareEvtAction }), " is misconfigured"),
                ].join(" "));
                return next(action);
            }
            var _a = __read(action.type.split("/")), sliceName = _a[0], actionName = _a[1], lifecycleStage = _a.slice(2);
            var out = next(action);
            evtAction.post(__assign(__assign({ sliceName: sliceName, actionName: actionName }, (lifecycleStage.length === 0
                ? {}
                : {
                    "lifecycleStage": lifecycleStage.join("/"),
                })), { "payload": action.payload }));
            return out;
        }; }; };
        return { "evtAction": evtAction, middlewareEvtAction: middlewareEvtAction };
    }
    return { createMiddlewareEvtAction: createMiddlewareEvtAction };
}
exports.createMiddlewareEvtActionFactory = createMiddlewareEvtActionFactory;
//# sourceMappingURL=middlewareEvtAction.js.map