@shopify/app-bridge-host/store/async.js

"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);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isReducerLoaded = exports.createActionsQueue = exports.createAddReducer = exports.createStore = exports.createReducers = exports.APP_BRIDGE_KEY = void 0;
var redux_1 = require("redux");
var actions_1 = require("../actions");
var features_1 = require("./reducers/embeddedApp/features");
var utilities_1 = require("./reducers/embeddedApp/utilities");
/**
 * The constant key `appBridge`
 * @public
 */
exports.APP_BRIDGE_KEY = 'appBridge';
/**
 * Returns a combined reducer for the `appBridge` key
 * Always includes the `features` reducer
 * @public
 * @param stateReducers - a reducer map for the dynamic app state
 * @param initialState - an optional default value for the store
 */
function createReducers(stateReducers, initialState) {
    var _a;
    if (stateReducers === void 0) { stateReducers = {}; }
    if (initialState === void 0) { initialState = {}; }
    var allReducers = redux_1.combineReducers((_a = {},
        _a[exports.APP_BRIDGE_KEY] = redux_1.combineReducers(utilities_1.wrapReducers(__assign({ features: features_1.asyncFeaturesReducer }, stateReducers), utilities_1.resetAppReducer, initialState)),
        _a));
    return function (state, action) {
        var _a, _b, _c;
        if (state === void 0) { state = (_a = {}, _a[exports.APP_BRIDGE_KEY] = { features: {} }, _a); }
        if (actions_1.isLoadReducerAction(action)) {
            var feature = action.payload.feature;
            var currenState = state[exports.APP_BRIDGE_KEY];
            return _b = {},
                _b[exports.APP_BRIDGE_KEY] = __assign(__assign({}, currenState), (_c = {}, _c[feature] = initialState[feature], _c)),
                _b;
        }
        return allReducers(state, action);
    };
}
exports.createReducers = createReducers;
/**
 * Creates a store containing only the default `features` reducer
 * @public
 */
function createStore(middleware, initialState, debug) {
    var _a;
    if (middleware === void 0) { middleware = []; }
    if (initialState === void 0) { initialState = {}; }
    if (debug === void 0) { debug = false; }
    var defaultState = (_a = {}, _a[exports.APP_BRIDGE_KEY] = initialState, _a);
    var composeEnhancers = debug && typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
        ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({ name: 'App Bridge', shouldHotReload: false })
        : redux_1.compose;
    return redux_1.createStore(createReducers({}, initialState), defaultState, composeEnhancers(redux_1.applyMiddleware.apply(void 0, middleware)));
}
exports.createStore = createStore;
/**
 * Creates a method that when called, dynamically adds a reducer to
 * the provided store
 * @internal
 * @param store - a Redux store
 * @param globalInitialState - custom overrides for resolving the app state when adding a new reducer
 * */
function createAddReducer(store, globalInitialState) {
    if (globalInitialState === void 0) { globalInitialState = {}; }
    var asyncReducers = {};
    return function addReducer(_a) {
        var _b;
        var key = _a.key, reducer = _a.reducer, initialState = _a.initialState;
        if (Object.prototype.hasOwnProperty.call(asyncReducers, key)) {
            return;
        }
        asyncReducers[key] = reducer;
        store.replaceReducer(createReducers(asyncReducers, __assign((_b = {}, _b[key] = initialState, _b), globalInitialState)));
        store.dispatch(actions_1.hostLoadReducer(key));
        store.dispatch(actions_1.hostLoadCompleteReducer(key));
    };
}
exports.createAddReducer = createAddReducer;
/**
 * Creates an action queue for the provided store
 * @internal
 * */
function createActionsQueue(store) {
    var queue = new Map();
    return {
        add: function (context, action) {
            if (!queue.has(context)) {
                queue.set(context, new Set());
            }
            var contextQueue = queue.get(context);
            contextQueue.add(action);
        },
        clear: function (context) {
            var contextQueue = queue.get(context);
            if (contextQueue) {
                contextQueue.clear();
            }
        },
        resolve: function (feature) {
            queue.forEach(function (contextQueue) {
                contextQueue.forEach(function (action) {
                    var actionKey = groupToFeatureKey(action.group);
                    if (actionKey === feature) {
                        store.dispatch(action);
                        contextQueue.delete(action);
                    }
                });
            });
        },
    };
}
exports.createActionsQueue = createActionsQueue;
/**
 * Returns the reducer key from a group
 * @internal
 */
function groupToFeatureKey(group) {
    return group[0].toLowerCase().concat(group.substr(1).replace('_', ''));
}
/**
 * Predicate to determine if a reducer for the associated action is already loaded
 * @internal
 */
function isReducerLoaded(state, action) {
    var key = groupToFeatureKey(action.group);
    return Object.prototype.hasOwnProperty.call(state, key);
}
exports.isReducerLoaded = isReducerLoaded;