@tramvai/state 2.70.0 → 2.72.0

package/lib/dispatcher/dispatcherContext.es.js

@@ -0,0 +1,279 @@
+import compose from '@tinkoff/utils/function/compose';
+import { subscribe } from './storeSubscribe.es.js';
+import { SimpleEmitter } from '../stores/SimpleEmitter.es.js';
+
+const eventExecutor = (event, handlerFns) => {
+    const keys = Object.keys(handlerFns);
+    for (let index = 0; index < keys.length; index++) {
+        const storeName = keys[index];
+        const handlerFn = handlerFns[storeName];
+        if (!handlerFn) {
+            throw new Error(`${storeName} does not have a handler for action ${event.type}`);
+        }
+        handlerFn(event.payload, event.type);
+    }
+};
+// Конвертация старого типа экшенов в новый
+const convertAction = (actionOrNameEvent, payload) => {
+    if (typeof actionOrNameEvent === 'string') {
+        return {
+            payload,
+            type: actionOrNameEvent,
+            error: false,
+        };
+    }
+    return actionOrNameEvent;
+};
+// Это форкнутый вариант dispatchr
+class DispatcherContext extends SimpleEmitter {
+    /**
+     * @param context The context to be used for store instances
+     */
+    constructor(dispatcher, context, initialState, middlewares) {
+        super();
+        this.applyDispatch = (event) => {
+            const eventHandlers = this.dispatcher.handlers[event.type] || [];
+            if (!eventHandlers.length) {
+                if (process.env.NODE_ENV === 'development') {
+                    console.warn(`
+The event "${event.type}" has been dispatched, but no reducers for this event were registered.
+Have you forgot to register reducer or add event handler in existing reducer?
+`);
+                }
+                return event.payload;
+            }
+            this.applyHandlers(event, eventHandlers);
+            return event.payload;
+        };
+        this.dispatcher = dispatcher;
+        this.storeInstances = {};
+        this.storeUnsubscribeCallbacks = {};
+        this.context = context;
+        this.dispatcherInterface = {
+            getContext: () => this.context,
+            getStore: this.getStore.bind(this),
+        };
+        this.rehydratedStoreState = {};
+        this.fullState = {};
+        // Заполняем стейт данными
+        if (initialState) {
+            this.rehydrate(initialState);
+        }
+        if (middlewares === null || middlewares === void 0 ? void 0 : middlewares.length) {
+            this.applyDispatch = this.applyMiddlewares(middlewares);
+        }
+        // Инцииализируем уже имеющиеся сторы
+        Object.keys(this.dispatcher.stores).forEach((store) => {
+            this.getStore(store);
+        });
+    }
+    applyMiddlewares(middlewares) {
+        let dispatch = (...args) => {
+            throw new Error('Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.');
+        };
+        const api = {
+            getState: this.getState.bind(this),
+            subscribe: this.subscribe.bind(this),
+            dispatch: (...args) => dispatch(...args),
+        };
+        dispatch = compose(...middlewares.map((middleware) => middleware(api)))(this.applyDispatch);
+        return dispatch;
+    }
+    storeSubscribe(storeName, storeInstance) {
+        const subscribeHandler = () => {
+            const newState = storeInstance.getState();
+            if (newState !== this.fullState[storeName]) {
+                this.fullState = {
+                    ...this.fullState,
+                    [storeName]: newState,
+                };
+                this.emit('change');
+            }
+        };
+        subscribe(storeInstance, subscribeHandler);
+        const unsubscribe = () => {
+            storeInstance.off('change', subscribeHandler);
+        };
+        this.storeUnsubscribeCallbacks[storeName] = unsubscribe;
+    }
+    // eslint-disable-next-line max-statements
+    getStore(storeClass) {
+        let storeClassPrepared;
+        let optional = false;
+        if (typeof storeClass === 'object') {
+            storeClassPrepared = storeClass.store;
+            optional = storeClass.optional;
+        }
+        else {
+            storeClassPrepared = storeClass;
+        }
+        const storeName = this.dispatcher.getStoreName(storeClassPrepared);
+        if (!this.storeInstances[storeName]) {
+            let Store = this.dispatcher.stores[storeName];
+            if (!Store) {
+                if (typeof storeClassPrepared === 'function') {
+                    this.dispatcher.registerStore(storeClassPrepared);
+                    Store = storeClassPrepared;
+                }
+                else {
+                    if (optional) {
+                        return null;
+                    }
+                    throw new Error(`Store ${storeName} was not registered.`);
+                }
+            }
+            const storeInstance = new Store(this.dispatcherInterface);
+            this.storeInstances[storeName] = storeInstance;
+            if (this.rehydratedStoreState && this.rehydratedStoreState[storeName]) {
+                const state = this.rehydratedStoreState[storeName];
+                if (storeInstance.rehydrate) {
+                    storeInstance.rehydrate(state);
+                }
+                this.rehydratedStoreState[storeName] = null;
+            }
+            this.storeSubscribe(storeName, storeInstance);
+            // TODO: убрать после того отпадёт надобность связывать сторы router и application
+            if (Store.dependencies) {
+                Store.dependencies.forEach((dependencyStoreClass) => {
+                    const dependency = this.getStore(dependencyStoreClass);
+                    subscribe(dependency, () => {
+                        storeInstance.emit('change');
+                    });
+                });
+            }
+        }
+        return this.storeInstances[storeName];
+    }
+    /**
+     * Dispatches a new action or throws if one is already in progress
+     * @param eventOrType Name of the event to be dispatched
+     * @param payload Parameters to describe the action
+     * @throws {Error} if store has handler registered that does not exist
+     */
+    dispatch(eventOrType, payload) {
+        if (!eventOrType) {
+            throw new Error(`eventOrType parameter ${eventOrType} is invalid.`);
+        }
+        // конвертим старый тип экшенов
+        const event = convertAction(eventOrType, payload);
+        return this.applyDispatch(event);
+    }
+    applyHandlers(action, handlers) {
+        const handlerFns = {};
+        const storeInstanceGet = (store) => {
+            if (handlerFns[store.name]) {
+                // Don't call the default if the store has an explicit action handler
+                return;
+            }
+            const storeInstance = this.getStore(store.name);
+            if (!storeInstance) {
+                return;
+            }
+            if (typeof store.handler === 'function') {
+                handlerFns[store.name] = store.handler.bind(storeInstance);
+            }
+            else {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!storeInstance[store.handler]) {
+                        throw new Error(`${store.name} does not have a method called ${store.handler}`);
+                    }
+                }
+                handlerFns[store.name] = storeInstance[store.handler].bind(storeInstance);
+            }
+        };
+        const handlersLength = handlers.length;
+        for (let index = 0; index < handlersLength; index++) {
+            storeInstanceGet(handlers[index]);
+        }
+        return eventExecutor(action, handlerFns);
+    }
+    /**
+     * Returns a raw data object representation of the current state of the
+     * dispatcher and all store instances. If the store implements a shouldDehdyrate
+     * function, then it will be called and only dehydrate if the method returns `true`
+     * @method dehydrate
+     * @returns dehydrated dispatcher data
+     */
+    dehydrate() {
+        const stores = {};
+        const keys = Object.keys(this.storeInstances);
+        for (let i = 0; i < keys.length; i++) {
+            const storeName = keys[i];
+            const store = this.storeInstances[storeName];
+            if (!store.dehydrate()) {
+                continue;
+            }
+            stores[storeName] = store.dehydrate();
+        }
+        return {
+            stores,
+        };
+    }
+    /**
+     * Takes a raw data object and rehydrates the dispatcher and store instances
+     * @method rehydrate
+     * @param dispatcherState raw state typically retrieved from `dehydrate` method
+     */
+    rehydrate(dispatcherState) {
+        if (dispatcherState.stores) {
+            const keys = Object.keys(dispatcherState.stores);
+            for (let index = 0; index < keys.length; index++) {
+                const storeName = keys[index];
+                this.rehydratedStoreState[storeName] = dispatcherState.stores[storeName];
+            }
+        }
+    }
+    subscribe(...args) {
+        if ('storeName' in args[0]) {
+            const reducer = args[0];
+            const callback = args[1];
+            const reducerInstance = this.getStore(reducer);
+            const listener = () => {
+                const state = this.getState(reducer);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                callback(state);
+            };
+            reducerInstance.on('change', listener);
+            return () => {
+                reducerInstance.off('change', listener);
+            };
+        }
+        const callback = args[0];
+        const listener = () => {
+            const state = this.getState();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            callback(state);
+        };
+        this.on('change', listener);
+        return () => {
+            this.off('change', listener);
+        };
+    }
+    getState(reducer) {
+        if (reducer) {
+            return this.fullState[reducer.storeName];
+        }
+        return this.fullState;
+    }
+    // Для отложенной инициализации контекста, в будующем нужно удалить
+    setContext(context) {
+        this.context = context;
+    }
+    hasStore(store) {
+        return store.storeName in this.storeInstances && this.dispatcher.hasStore(store);
+    }
+    registerStore(store) {
+        this.dispatcher.registerStore(store);
+        this.getStore(store);
+    }
+    unregisterStore(store) {
+        const { storeName } = store;
+        this.dispatcher.unregisterStore(store);
+        this.storeUnsubscribeCallbacks[storeName]();
+        delete this.storeUnsubscribeCallbacks[storeName];
+        delete this.rehydratedStoreState[storeName];
+        delete this.storeInstances[storeName];
+    }
+}
+
+export { DispatcherContext, convertAction };

package/lib/dispatcher/dispatcherContext.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compose = require('@tinkoff/utils/function/compose');
+var storeSubscribe = require('./storeSubscribe.js');
+var SimpleEmitter = require('../stores/SimpleEmitter.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
+
+const eventExecutor = (event, handlerFns) => {
+    const keys = Object.keys(handlerFns);
+    for (let index = 0; index < keys.length; index++) {
+        const storeName = keys[index];
+        const handlerFn = handlerFns[storeName];
+        if (!handlerFn) {
+            throw new Error(`${storeName} does not have a handler for action ${event.type}`);
+        }
+        handlerFn(event.payload, event.type);
+    }
+};
+// Конвертация старого типа экшенов в новый
+const convertAction = (actionOrNameEvent, payload) => {
+    if (typeof actionOrNameEvent === 'string') {
+        return {
+            payload,
+            type: actionOrNameEvent,
+            error: false,
+        };
+    }
+    return actionOrNameEvent;
+};
+// Это форкнутый вариант dispatchr
+class DispatcherContext extends SimpleEmitter.SimpleEmitter {
+    /**
+     * @param context The context to be used for store instances
+     */
+    constructor(dispatcher, context, initialState, middlewares) {
+        super();
+        this.applyDispatch = (event) => {
+            const eventHandlers = this.dispatcher.handlers[event.type] || [];
+            if (!eventHandlers.length) {
+                if (process.env.NODE_ENV === 'development') {
+                    console.warn(`
+The event "${event.type}" has been dispatched, but no reducers for this event were registered.
+Have you forgot to register reducer or add event handler in existing reducer?
+`);
+                }
+                return event.payload;
+            }
+            this.applyHandlers(event, eventHandlers);
+            return event.payload;
+        };
+        this.dispatcher = dispatcher;
+        this.storeInstances = {};
+        this.storeUnsubscribeCallbacks = {};
+        this.context = context;
+        this.dispatcherInterface = {
+            getContext: () => this.context,
+            getStore: this.getStore.bind(this),
+        };
+        this.rehydratedStoreState = {};
+        this.fullState = {};
+        // Заполняем стейт данными
+        if (initialState) {
+            this.rehydrate(initialState);
+        }
+        if (middlewares === null || middlewares === void 0 ? void 0 : middlewares.length) {
+            this.applyDispatch = this.applyMiddlewares(middlewares);
+        }
+        // Инцииализируем уже имеющиеся сторы
+        Object.keys(this.dispatcher.stores).forEach((store) => {
+            this.getStore(store);
+        });
+    }
+    applyMiddlewares(middlewares) {
+        let dispatch = (...args) => {
+            throw new Error('Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.');
+        };
+        const api = {
+            getState: this.getState.bind(this),
+            subscribe: this.subscribe.bind(this),
+            dispatch: (...args) => dispatch(...args),
+        };
+        dispatch = compose__default["default"](...middlewares.map((middleware) => middleware(api)))(this.applyDispatch);
+        return dispatch;
+    }
+    storeSubscribe(storeName, storeInstance) {
+        const subscribeHandler = () => {
+            const newState = storeInstance.getState();
+            if (newState !== this.fullState[storeName]) {
+                this.fullState = {
+                    ...this.fullState,
+                    [storeName]: newState,
+                };
+                this.emit('change');
+            }
+        };
+        storeSubscribe.subscribe(storeInstance, subscribeHandler);
+        const unsubscribe = () => {
+            storeInstance.off('change', subscribeHandler);
+        };
+        this.storeUnsubscribeCallbacks[storeName] = unsubscribe;
+    }
+    // eslint-disable-next-line max-statements
+    getStore(storeClass) {
+        let storeClassPrepared;
+        let optional = false;
+        if (typeof storeClass === 'object') {
+            storeClassPrepared = storeClass.store;
+            optional = storeClass.optional;
+        }
+        else {
+            storeClassPrepared = storeClass;
+        }
+        const storeName = this.dispatcher.getStoreName(storeClassPrepared);
+        if (!this.storeInstances[storeName]) {
+            let Store = this.dispatcher.stores[storeName];
+            if (!Store) {
+                if (typeof storeClassPrepared === 'function') {
+                    this.dispatcher.registerStore(storeClassPrepared);
+                    Store = storeClassPrepared;
+                }
+                else {
+                    if (optional) {
+                        return null;
+                    }
+                    throw new Error(`Store ${storeName} was not registered.`);
+                }
+            }
+            const storeInstance = new Store(this.dispatcherInterface);
+            this.storeInstances[storeName] = storeInstance;
+            if (this.rehydratedStoreState && this.rehydratedStoreState[storeName]) {
+                const state = this.rehydratedStoreState[storeName];
+                if (storeInstance.rehydrate) {
+                    storeInstance.rehydrate(state);
+                }
+                this.rehydratedStoreState[storeName] = null;
+            }
+            this.storeSubscribe(storeName, storeInstance);
+            // TODO: убрать после того отпадёт надобность связывать сторы router и application
+            if (Store.dependencies) {
+                Store.dependencies.forEach((dependencyStoreClass) => {
+                    const dependency = this.getStore(dependencyStoreClass);
+                    storeSubscribe.subscribe(dependency, () => {
+                        storeInstance.emit('change');
+                    });
+                });
+            }
+        }
+        return this.storeInstances[storeName];
+    }
+    /**
+     * Dispatches a new action or throws if one is already in progress
+     * @param eventOrType Name of the event to be dispatched
+     * @param payload Parameters to describe the action
+     * @throws {Error} if store has handler registered that does not exist
+     */
+    dispatch(eventOrType, payload) {
+        if (!eventOrType) {
+            throw new Error(`eventOrType parameter ${eventOrType} is invalid.`);
+        }
+        // конвертим старый тип экшенов
+        const event = convertAction(eventOrType, payload);
+        return this.applyDispatch(event);
+    }
+    applyHandlers(action, handlers) {
+        const handlerFns = {};
+        const storeInstanceGet = (store) => {
+            if (handlerFns[store.name]) {
+                // Don't call the default if the store has an explicit action handler
+                return;
+            }
+            const storeInstance = this.getStore(store.name);
+            if (!storeInstance) {
+                return;
+            }
+            if (typeof store.handler === 'function') {
+                handlerFns[store.name] = store.handler.bind(storeInstance);
+            }
+            else {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!storeInstance[store.handler]) {
+                        throw new Error(`${store.name} does not have a method called ${store.handler}`);
+                    }
+                }
+                handlerFns[store.name] = storeInstance[store.handler].bind(storeInstance);
+            }
+        };
+        const handlersLength = handlers.length;
+        for (let index = 0; index < handlersLength; index++) {
+            storeInstanceGet(handlers[index]);
+        }
+        return eventExecutor(action, handlerFns);
+    }
+    /**
+     * Returns a raw data object representation of the current state of the
+     * dispatcher and all store instances. If the store implements a shouldDehdyrate
+     * function, then it will be called and only dehydrate if the method returns `true`
+     * @method dehydrate
+     * @returns dehydrated dispatcher data
+     */
+    dehydrate() {
+        const stores = {};
+        const keys = Object.keys(this.storeInstances);
+        for (let i = 0; i < keys.length; i++) {
+            const storeName = keys[i];
+            const store = this.storeInstances[storeName];
+            if (!store.dehydrate()) {
+                continue;
+            }
+            stores[storeName] = store.dehydrate();
+        }
+        return {
+            stores,
+        };
+    }
+    /**
+     * Takes a raw data object and rehydrates the dispatcher and store instances
+     * @method rehydrate
+     * @param dispatcherState raw state typically retrieved from `dehydrate` method
+     */
+    rehydrate(dispatcherState) {
+        if (dispatcherState.stores) {
+            const keys = Object.keys(dispatcherState.stores);
+            for (let index = 0; index < keys.length; index++) {
+                const storeName = keys[index];
+                this.rehydratedStoreState[storeName] = dispatcherState.stores[storeName];
+            }
+        }
+    }
+    subscribe(...args) {
+        if ('storeName' in args[0]) {
+            const reducer = args[0];
+            const callback = args[1];
+            const reducerInstance = this.getStore(reducer);
+            const listener = () => {
+                const state = this.getState(reducer);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                callback(state);
+            };
+            reducerInstance.on('change', listener);
+            return () => {
+                reducerInstance.off('change', listener);
+            };
+        }
+        const callback = args[0];
+        const listener = () => {
+            const state = this.getState();
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            callback(state);
+        };
+        this.on('change', listener);
+        return () => {
+            this.off('change', listener);
+        };
+    }
+    getState(reducer) {
+        if (reducer) {
+            return this.fullState[reducer.storeName];
+        }
+        return this.fullState;
+    }
+    // Для отложенной инициализации контекста, в будующем нужно удалить
+    setContext(context) {
+        this.context = context;
+    }
+    hasStore(store) {
+        return store.storeName in this.storeInstances && this.dispatcher.hasStore(store);
+    }
+    registerStore(store) {
+        this.dispatcher.registerStore(store);
+        this.getStore(store);
+    }
+    unregisterStore(store) {
+        const { storeName } = store;
+        this.dispatcher.unregisterStore(store);
+        this.storeUnsubscribeCallbacks[storeName]();
+        delete this.storeUnsubscribeCallbacks[storeName];
+        delete this.rehydratedStoreState[storeName];
+        delete this.storeInstances[storeName];
+    }
+}
+
+exports.DispatcherContext = DispatcherContext;
+exports.convertAction = convertAction;

package/lib/dispatcher/storeSubscribe.es.js

@@ -0,0 +1,8 @@
+const subscribe = (store, handler) => {
+    // подписываемся на изменения
+    store.on('change', handler);
+    // вызываем сразу, чтобы заполнить начальное состояние
+    handler();
+};
+
+export { subscribe };

package/lib/dispatcher/storeSubscribe.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const subscribe = (store, handler) => {
+    // подписываемся на изменения
+    store.on('change', handler);
+    // вызываем сразу, чтобы заполнить начальное состояние
+    handler();
+};
+
+exports.subscribe = subscribe;