Часть 1. Кастомный хук

Часть 2. Генераторы

Redux-saga

Это middleware для управления сайд эффектами при работе с redux. В основе лежит механизм генераторов. Т.е. код ставится на паузу пока не будет выполнена определенная операция с эффектом - это объект с определенным типом и данными.

Можно представить себе redux-saga (middleware) как администратора камер хранения. В камеры хранения можно класть эффекты на неопределенный срок и забирать их оттуда, когда будет нужно. Есть такой посыльный put, который приходит к диспетчеру и просит положить в камеру хранения сообщение (эффект). Есть такой посыльный take, который приходит к диспетчеру и просит ему выдать сообщение с определенным типом (эффект). Диспетчер, по просьбе take, смотрит все камеры хранения и если этих данных нет, то take остаётся с диспетчером и ждёт, пока put не принесёт данные с нужным для take типом. Существуют разные виды таких посыльных (takeEvery и т.д.).

Основная идея камер хранения - это "развести" во времени отправителя и получателя (некий аналог асинхронных обработки).

Redux-saga - это просто инструмент, а вот главным тут является тот, кто посылает всех этих посыльных и обрабатывает данные, которые они приносят. Этим "кто-то" является функция-генератор (назову её пассажир), которая в справке называется saga и передаётся при запуске middleware. Запустить middleware можно двумя способами: с помощью middleware.run(saga, ...args) и runSaga(options, saga, ...args). Saga - это функция-генератор с логикой обработки эффектов.

Меня заинтересовала возможность использования redux-saga для обработки внешних событий без redux. Рассмотрю метод runSaga(...) подробнее:

runSaga(options, saga, ...args)

saga - это метод, в котором будет выполняться логика;

args - аргументы, которые будут переданы в saga;

options - объект, который "настраивает" работу redux-saga. Для данного хука использую всего три настройки:

channel - канал, из которого будут поступать внешние события;

dispatch - это метод, который при возникновении события, должен послать redux-saga эффект с помощью put.

getState - функция, которая используется для выборки данных из state, с которым используется redux-saga. В случае с хуком это будет локальный state.

Вариант 6. Redux-saga как канал обработки внешних сообщений

Логика работы хука с saga будет такова. Создаётся канал channel (камеры хранения) для хранения эффектов в процессе работы redux-saga. Создаётся канал, в который будут поступать внешние события от изображений - eventsChannel. Это два разных канала! Вернусь к аналогии с камерами хранения.

Создаются камеры хранения (channel), которым потом будет назначен администратор (redux-saga)

const sagaChannelRef = useRef(stdChannel());

При запуске runSaga() redux-saga назначается администратором созданных камер хранения.

runSaga(  {    channel: sagaChannelRef.current,    dispatch: () => {},    getState: () => {},  },  saga);

Камеры хранения созданы (channel), администратор назначен (redux-saga) и далее этим всем начинает пользоваться пассажир (происходит запуск функции-генератора saga)

Первым делом пассажир (функция-генератор saga) создает канал для внешних событий (конечно этих каналов может быть несколько от разных источников).

const eventsChannel = yield call(getImageLoadingSagas, imgArray);

function getImageLoadingSagas(imagesArray) {  return eventChannel((emit) => {    for (const img of imagesArray) {      const imageChecker = new Image();      imageChecker.addEventListener("load", () => {        emit(true);      });      imageChecker.addEventListener("error", () => {        emit(true);      });      imageChecker.src = img.url;    }    setTimeout(() => {      //закрытие канала по таймеру      emit(END);    }, 100000);    return () => {    };  }, buffers.expanding(10));}

Т.е. пассажир (функция-генератор saga) просит диспетчера (redux-saga) принимать сообщения не только от посыльного put, но и от другого источника (eventsChannel). Сообщения от этого источника (eventChannel) у диспетчера (redux-saga) будет забирать, специально выделенный для этого, посыльный take, который стоит рядом с диспетчером и ждёт от него сообщения.

yield take(eventsChannel);

Как только диспетчеру (redux-saga) приходит сообщение от eventChannel, он тут же отдает его take, который возвращает сообщение пассажиру (функции-генератору saga). Сам take остаётся рядом с пассажиром и ждёт от него указаний.

Пассажир (функция-генератор saga) отдает это сообщение на обработку другому пассажиру (функции-генератору putCounter) с помощью call(). Это означает, что пассажир saga (функция-генератор saga) будет ожидать, пока пассажир putCounter (функция-генератор putCounter) не освободится (т.е. saga блокируется, пока не отработает функция putCounter).

yield call(putCounter);

function* putCounter() {  dispatch({    type: ACTIONS.SET_COUNTER,    data: stateRef.current.counter + stateRef.current.counterStep,  });  yield take((action) => {    return action.type === "STATE_UPDATED";  });}

Чем занимается пассажир putCounter (функция-генератор putCounter). Диспатчит действие состояния хука и затем посылает посыльного take к диспетчеру (redux-saga) за сообщением с типом STATE_UPDATED и ждёт этого посыльного.

В этом месте остановимся и ещё раз опишем получившийся хоровод (сделаем срез на этот момент).

Посыльный take(eventChannel) стоит (ожидает пока не выполнится итерация цикла в функции-генераторе saga) рядом с пассажиром saga (функцией-генератором saga). Пассажир saga (функция-генератор saga) ожидает пока пассажир putCounter (функция-генератор putCounter) не освободится. Пассажир putCounter (функция-генератор putCounter), в свою очередь, ждёт посыльного take, который стоит рядом с диспетчером (redux-saga) и ждёт посыльного put, который должен принести сообщение с типом STATE_UPDATED. Короче "Дом, который построил Джек".

Таким образом весь хоровод "застыл" в ожидании одного-единственного сообщения STATE_UPDATED. Кстати, в канале eventChannel могут возникать события во время этого застывшего состояния. Если не использовать буфер с каналом eventChannel, то эти события останутся незамеченными для нашего диспетчера (redux-saga). Но буфер у нас есть, поэтому в это время в тамбуре перед камерами хранения (буфере) толпятся сообщения от eventChannel.

И этого посыльного put отправляет хук useEffect

useEffect(() => {...    sagaChannelRef.current.put({ type: "STATE_UPDATED" }); ...}, [state]);

Посыльный put приносит сообщение STATE_UPDATED диспетчеру (redux-saga).

Диспетчер (redux-saga) отдаёт его take, которого прислал пассажир putCounter.

Пассажир putCounter сообщает пассажиру saga, что он освободился.

Пассажир saga, отправляет посыльного take за следующим сообщением от eventChannel

Take забирает следующее сообщение у диспетчера, который взял его из буфера.

Круг замкнулся.

import { useReducer, useEffect, useRef } from "react";import { reducer, initialState, ACTIONS } from "./state";import { runSaga, eventChannel, stdChannel, buffers, END } from "redux-saga";import { call, take } from "redux-saga/effects";const PRELOADER_SELECTOR = ".preloader__wrapper";const PRELOADER_COUNTER_SELECTOR = ".preloader__counter";const usePreloader = () => {  const [state, dispatch] = useReducer(reducer, initialState);  const stateRef = useRef(state);  const sagaChannelRef = useRef(stdChannel());  const preloaderEl = document.querySelector(PRELOADER_SELECTOR);  const counterEl = document.querySelector(PRELOADER_COUNTER_SELECTOR);  useEffect(() => {    const imgArray = document.querySelectorAll("img");    if (imgArray.length > 0) {      dispatch({        type: ACTIONS.SET_COUNTER_STEP,        data: Math.floor(100 / imgArray.length) + 1,      });      function* putCounter() {        dispatch({          type: ACTIONS.SET_COUNTER,          data: stateRef.current.counter + stateRef.current.counterStep,        });        yield take((action) => {          return action.type === "STATE_UPDATED";        });      }      function* saga() {        const eventsChannel = yield call(getImageLoadingSagas, imgArray);        try {          while (true) {            yield take(eventsChannel);            yield call(putCounter);          }        } finally {          //channel closed        }      }      runSaga(        {          channel: sagaChannelRef.current,          dispatch: () => {},          getState: () => {},        },        saga      );    }  }, []);  useEffect(() => {    stateRef.current = state;    if (stateRef.current.counterStep != 0 && stateRef.current.counter != 0) {      sagaChannelRef.current.put({ type: "STATE_UPDATED" });    }    if (counterEl) {      stateRef.current.counter < 100        ? (counterEl.innerHTML = `${stateRef.current.counter}%`)        : hidePreloader(preloaderEl);    }  }, [state]);  return;};function getImageLoadingSagas(imagesArray) {  return eventChannel((emit) => {    for (const img of imagesArray) {      const imageChecker = new Image();      imageChecker.addEventListener("load", () => {        emit(true);      });      imageChecker.addEventListener("error", () => {        emit(true);      });      imageChecker.src = img.url;    }    setTimeout(() => {      //закрытие канала по таймеру      emit(END);    }, 100000);    return () => {          };  }, buffers.expanding(10));}const hidePreloader = (preloaderEl) => {  preloaderEl.remove();};export default usePreloader;

Я был трезвый, когда это писал. Чтобы прочитать, пить тоже не нужно.

Вариант 7. Redux-saga + useReducer = useReducerAndSaga

В варианте 6 сага использовалась исключительно как менеджер событий. Мне хотелось подключить его к управлению state хука. Погуглив нашёл такой вариант хука useReducerAndSaga

Описывать на примере камер хранения не буду, просто приведу исходный код

import { useReducer, useEffect, useRef } from "react";import { runSaga, stdChannel, buffers } from "redux-saga";export function useReducerAndSaga(reducer, state0, saga, sagaOptions) {  const [state, reactDispatch] = useReducer(reducer, state0);  const sagaEnv = useRef({ state: state0, pendingActions: [] });  function dispatch(action) {    console.log("useReducerAndSaga: react dispatch", action);    reactDispatch(action);    console.log("useReducerAndSaga: post react dispatch", action);    // dispatch to sagas is done in the commit phase    sagaEnv.current.pendingActions.push(action);  }  useEffect(() => {    console.log("useReducerAndSaga: update saga state");    // sync with react state, *should* be safe since we're in commit phase    sagaEnv.current.state = state;    const pendingActions = sagaEnv.current.pendingActions;    // flush any pending actions, since we're in commit phase, reducer    // should've handled all those actions    if (pendingActions.length > 0) {      sagaEnv.current.pendingActions = [];      console.log("useReducerAndSaga: flush saga actions");      pendingActions.forEach((action) => sagaEnv.current.channel.put(action));      sagaEnv.current.channel.put({ type: "REACT_STATE_READY", state });    }  });  // This is a one-time effect that starts the root saga  useEffect(() => {    sagaEnv.current.channel = stdChannel();    const task = runSaga(      {        ...sagaOptions,        channel: sagaEnv.current.channel,        dispatch,        getState: () => {          return sagaEnv.current.state;        }      },      saga    );    return () => task.cancel();  }, []);  return [state, dispatch];}

Все генераторы были выдесены в отдельный файл sagas.js

import { eventChannel, buffers } from "redux-saga";import { call, select, take, put } from "redux-saga/effects";import { ACTIONS, getCounterStep, getCounter, END } from "./state";export const getImageLoadingSagas = (imagesArray) => {  return eventChannel((emit) => {    for (const img of imagesArray) {      const imageChecker = new Image();            imageChecker.addEventListener("load", () => {        emit(true);      });      imageChecker.addEventListener("error", () => {        emit(true);      });      imageChecker.src = img.src;    }    setTimeout(() => {      //закрытие канала по таймеру      emit(END);    }, 100000);    return () => {};  }, buffers.fixed(20));};function* putCounter() {  const currentCounter = yield select(getCounter);  const counterStep = yield select(getCounterStep);  yield put({ type: ACTIONS.SET_COUNTER, data: currentCounter + counterStep });  yield take((action) => {    return action.type === "REACT_STATE_READY";  });}function* launchLoadingEvents(imgArray) {  const eventsChannel = yield call(getImageLoadingSagas, imgArray);  while (true) {    yield take(eventsChannel);    yield call(putCounter);  }}export function* saga() {  while (true) {    const { data } = yield take(ACTIONS.SET_IMAGES);    yield call(launchLoadingEvents, data);  }}

Немножко изменился state. Был добавлен action SET_IMAGES и селекторы для counter и counterStep

const SET_COUNTER = "SET_COUNTER";const SET_COUNTER_STEP = "SET_COUNTER_STEP";const SET_IMAGES = "SET_IMAGES";export const initialState = {  counter: 0,  counterStep: 0,  images: [],};export const reducer = (state, action) => {  switch (action.type) {    case SET_IMAGES:      return { ...state, images: action.data };    case SET_COUNTER:      return { ...state, counter: action.data };    case SET_COUNTER_STEP:      return { ...state, counterStep: action.data };    default:      throw new Error("This action is not applicable to this component.");  }};export const ACTIONS = {  SET_COUNTER,  SET_COUNTER_STEP,  SET_IMAGES,};export const getCounterStep = (state) => state.counterStep;export const getCounter = (state) => state.counter;

Благодаря этому рефакторингу, код хука usePreloader стал компактным.

import { useEffect } from "react";import { reducer, initialState, ACTIONS } from "./state";import { useReducerAndSaga } from "./useReducerAndSaga";import { saga } from "./sagas";const PRELOADER_SELECTOR = ".preloader__wrapper";const PRELOADER_COUNTER_SELECTOR = ".preloader__counter";const usePreloader = () => {  const [state, dispatch] = useReducerAndSaga(reducer, initialState, saga);  const preloaderEl = document.querySelector(PRELOADER_SELECTOR);  const counterEl = document.querySelector(PRELOADER_COUNTER_SELECTOR);  useEffect(() => {    const imgArray = document.querySelectorAll("img");    if (imgArray.length > 0) {      dispatch({        type: ACTIONS.SET_COUNTER_STEP,        data: Math.floor(100 / imgArray.length) + 1,      });      dispatch({        type: ACTIONS.SET_IMAGES,        data: imgArray,      });    }  }, []);  useEffect(() => {    if (counterEl) {      state.counter < 100        ? (counterEl.innerHTML = `${state.counter}%`)        : hidePreloader(preloaderEl);    }  }, [state.counter]);  return;};const hidePreloader = (preloaderEl) => {  preloaderEl.remove();};export default usePreloader;

Итого

В этой части статьи показано:

• что такое redux-saga

• как использовать redux-saga без redux

• как использовать redux-saga для управления состоянием хука

Ссылка напесочницу

Ссылка нарепозиторий

Продолжение следует... RxJS...

Попытка жалкого подобия на хуки useSelector, useDispatch, как в react-redux.

Большинство из нас сталкивались с redux, а те, кто использовал его в ReactJS могли пощупать хуки useSelector, useDispatch, в ином случае через mstp, mdtp + HOC connect. А что со svelte? Можно навернуть, или найти что-то похожее на connect, по типу svelte-redux-connect, описывать огромные конструкции, которые будем отдавать в тот самый connect:

const mapStateToProps = state => ({  users: state.users,  filters: state.filters});const mapDispatchToProps = dispatch => ({  addUser: (name) => dispatch({    type: 'ADD_USER',    payload: { name }  }),  setFilter: (filter) => dispatch({    type: 'SET_FILTER',    payload: { filter }  }) });

Прямо какие-то страшные флэшбэки до середины 2018, до введения хуков :). Хочу хуки в svelte. Что мы можем из него взять? Хм... store у svelte глобальный, не нужны никакие провайдеры с контекстом (шучу, нужны для разделения контекстов, но пока выкинем). Значит так: мы создаем redux-store, потом попробуем написать наши жалкие хуки для удобства использования.

Итак, наши константы:

//constants.jsexport const GET_USER = '@@user/get'export const FETCHING_USER = '@@user/fetch'export const SET_USER = '@@user/set'

Редюсер:

//user.jsimport {FETCHING_USER, SET_USER} from "./constants";const initialState = {  user: null,  isFetching: false}export default function user(state = initialState, action = {}){  switch (action.type){    case FETCHING_USER:    case SET_USER:      return {        ...state,        ...action.payload      }    default:      return state  }}

Экшены:

//actions.jsimport {FETCHING_USER, GET_USER, SET_USER} from "./constants";export const getUser = () => ({  type: GET_USER})export const setUser = (user) => ({  type: SET_USER,  payload: {    user  }})export const setIsFetchingUser = (isFetching) => ({  type: FETCHING_USER,  payload: {    isFetching  }})

Селекторы. К ним вернемся отдельно:

//selectors.jsimport {createSelector} from "reselect";import path from 'ramda/src/path'export const selectUser = createSelector(  path(['user', 'user']),  user => user)export const selectIsFetchingUser = createSelector(  path(['user', 'isFetching']),  isFetching => isFetching)

И главный combineReducers:

//rootReducer.jsimport {combineReducers} from "redux";import user from "./user/user";export const reducers = combineReducers({  user})

Теперь надо прикрутить redux-saga, а в качестве api у нас будет https://randomuser.me/api/. Во время тестирования всего процесса, эта апи очень быстро работала, а я очень сильно хотел посмотреть на лоадер подольше (у каждого свой мазохизм), поэтому я завернул таймаут в промис на 3 сек.

//saga.jsimport {takeLatest, put, call, cancelled} from 'redux-saga/effects'import {GET_USER} from "./constants";import {setIsFetchingUser, setUser} from "./actions";import axios from "axios";const timeout = () => new Promise(resolve => {  setTimeout(()=>{    resolve()  }, 3000)})function* getUser(){  const cancelToken = axios.CancelToken.source()  try{    yield put(setIsFetchingUser(true))    const response = yield call(axios.get, 'https://randomuser.me/api/', {cancelToken: cancelToken.token})    yield call(timeout)    yield put(setUser(response.data.results[0]))    yield put(setIsFetchingUser(false))  }catch (error){    console.error(error)  }finally {    if(yield cancelled()){      cancelToken.cancel('cancel fetching user')    }    yield put(setIsFetchingUser(false))  }}export default function* userSaga(){  yield takeLatest(GET_USER, getUser)}

//rootSaga.jsimport {all} from 'redux-saga/effects'import userSaga from "./user/saga";export default function* rootSaga(){  yield all([userSaga()])}

И наконец инициализация store:

//store.jsimport {applyMiddleware, createStore} from "redux";import {reducers} from "./rootReducer";import {composeWithDevTools} from 'redux-devtools-extension';import {writable} from "svelte/store";import createSagaMiddleware from 'redux-saga';import rootSaga from "./rootSaga";const sagaMiddleware = createSagaMiddleware()const middleware = applyMiddleware(sagaMiddleware)const store = createStore(reducers, composeWithDevTools(middleware))sagaMiddleware.run(rootSaga)// берем изначальное состояние из storeconst initialState = store.getState()// написали writable store для useSelectorexport const useSelector = writable((selector)=>selector(initialState))// написали writable store для useDispatch, хотя можно было и без этого// но для симметрии использования оставил такexport const useDispatch = writable(() => store.dispatch)// подписываемся на обновление storestore.subscribe(()=>{  const state = store.getState()  // при обновлении store обновляем useSelector, тут нет никакой мемоизации,   // проверки стейтов, обработки ошибок и прочего очень важного для оптимизации  useSelector.set(selector => selector(state))})

Всё. Самое интересное начинается с 18 строки. После того, как приходит понятие того, что мы написали, возникает вопрос - если я буду использовать useSelector в 3 разных компонентах с разными данными из store - у меня будут обновляться все компоненты сразу? Нет, обновятся и перерисуются данные, которые мы используем. Даже если логически предположить, что при каждом чихе в store у нас меняется ссылка на функцию, то и обновление компонента по идее должно быть, но его нет. Я честно не до конца разобрался как это работает, но я доберусь до сути, не ругайтесь :)

Хуки готовы, как использовать?

Начнем c useDispatch. Его вообще можно было не заворачивать в svelte-store и сделать просто
export const useDispatch = () => store.dispatch, только по итогу с useSelector мы используем store bindings, а с useDispatch нет - сорян, всё же во мне есть частичка маленького перфекционизма. Используем хук useDispatch в App.svelte:

<!--App.svelte--><script>  import {getUser} from "./store/user/actions";  import {useDispatch} from "./store/store";  import Loader from "./Loader.svelte";  import User from "./User.svelte";  // создаем диспатчер  const dispatch = $useDispatch()  const handleClick = () => {    // тригерим экшен    dispatch(getUser())  }</script><style>    .wrapper {        display: inline-block;        padding: 20px;    }    .button {        padding: 10px;        margin: 20px 0;        border: none;        background: #1d7373;        color: #fff;        border-radius: 8px;        outline: none;        cursor: pointer;    }    .heading {        line-height: 20px;        font-size: 20px;    }</style><div class="wrapper">    <h1 class="heading">Random user</h1>    <button class="button" on:click={handleClick}>Fetch user</button>    <Loader/>    <User/></div>

Вот такая вот загогулина у меня свёрстана. При нажатии на кнопку Fetch user, тригерим экшен GET_USER. Смотрим в Redux-dev-tools - экшен вызвался, всё хорошо. Смотрим network - запрос к апи выполнен, тоже всё хорошо:

Теперь нужно показать процесс загрузки и полученного нами пользователя. Используем useSelector:

<!--Loader.svelte--><script>    import {useSelector} from "./store/store";    import {selectIsFetchingUser} from "./store/user/selector";// Только в такой конструкции мы можем получить из store данные,     // выглядит не так страшно и не лагает, я проверял :3    $: isFetchingUser = $useSelector(selectIsFetchingUser)</script><style>    @keyframes loading {        0% {            background: #000;            color: #fff;        }        100% {            background: #fff;            color: #000;        }    }    .loader {        background: #fff;        box-shadow: 0px 0px 7px rgba(0,0,0,0.3);        padding: 10px;        border-radius: 8px;        transition: color 0.3s ease-in-out, background 0.3s ease-in-out;        animation: loading 3s ease-in-out forwards;    }</style>{#if isFetchingUser}    <div class="loader">Loading...</div>{/if}

Лоадер рисуется. Данные из store прилетают, теперь надо показать юзера:

<!--User.svelte--><script>    import {useSelector} from "./store/store";    import {selectIsFetchingUser,selectUser} from "./store/user/selector";    $: user = $useSelector(selectUser)    $: isFetchingUser = $useSelector(selectIsFetchingUser)</script><style>    .user {        background: #fff;        box-shadow: 0px 0px 7px rgba(0,0,0,0.3);        display: grid;        padding: 20px;        justify-content: center;        align-items: center;        border-radius: 8px;    }    .user-image {        width: 100px;        height: 100px;        background-position: center;        background-size: contain;        border-radius: 50%;        margin-bottom: 20px;        justify-self: center;    }</style>{#if user && !isFetchingUser}    <div class="user">        <div class="user-image" style={`background-image: url(${user.picture.large});`}></div>        <div>{user.name.title}. {user.name.first} {user.name.last}</div>    </div>{/if}

Пользователя так же получили.

Итог

Запилили какие-никакие подобия на хуки, вроде удобно, но не известно как это отразится в будущем, если сделать из этого mini-app на пару страниц. Саги так же пашут. Через redux devtools можно дебажить redux и прыгать от экшена к экшену, всё хорошо работает.