How to use the redux-persist.createTransform function in redux-persist

// redux-persist value transforms to store and restore non serializable state
import { createTransform } from 'redux-persist';

import { makeDefaultOutputs } from '../components/RCONTerminal/defaults';
import { ServersState } from '../redux/servers';
import { OnTickFunctionFactory, TasksState } from '../redux/tasks';
import { Terminal } from '../redux/terminal/types';
import { decryptPassword, encryptPassword } from './crypto';

// Null out our cronjob and stringify <-> functionify onTick
export const functionTransform = createTransform(
  // Called before state is persisted
  (inboundState: TasksState) => {
    return inboundState.map(task => {
      return {
        ...task,
        job: null,
        onTick: String(task.onTick)
      };
    });
  },
  // Called before state is rehydrated
  outboundState => {
    return outboundState.map((task: any) => ({
      ...task,
      job: null,
      onTick: eval(task.onTick) as OnTickFunctionFactory // tslint:disable-line

const defaults = {
    // Key to be used for the time relative to which store is to be expired
    persistedAtKey: '__persisted_at',
    // Seconds after which store will be expired
    expireSeconds: null,
    // State to be used for resetting e.g. provide initial reducer state
    expiredState: {},
    // Use it if you don't want to manually set the time and want the store to
    // be automatically expired if the record is not updated in the `expireSeconds` time
    autoExpire: false
  };

  config = Object.assign({}, defaults, config);

  return createTransform(
    // transform state on its way to being serialized and persisted.
    (inboundState) => transformPersistence(inboundState, config),
    // transform state being rehydrated
    (outboundState) => transformRehydrate(outboundState, config),
    // define which reducers this transform gets called for.
    {
      whitelist: [reducerKey]
    }
  );
}

import reduxThunk from 'redux-thunk';
import { persistReducer, persistStore, createTransform } from 'redux-persist';
import rootReducer from '../reducer';
import enhancers from './enhancers';
import screenTrackingMiddleware from './screenTrackingMiddleware';

// Note: logger must be the last middleware in chain,
// otherwise it will log thunk and promise, not actual actions
const sagaMiddleware = createSagaMiddleware();
const middlewares = [reduxThunk, screenTrackingMiddleware, sagaMiddleware];
if (__DEV__) {
  const { logger } = require('redux-logger'); // eslint-disable-line
  middlewares.unshift(logger);
}

const myTransform = createTransform(
  // transform state coming from redux on its way to being serialized and stored
  state => (Immutable.isImmutable(state) ? Immutable.asMutable(state) : state),
  // transform state coming from storage, on its way to be rehydrated into redux
  state => Immutable(state)
)

const config = {
  key: 'root',
  debug: true,
  blacklist: ['nav', '_persist'],
  transforms: [myTransform],
  storage,
};

export const store = createStore(
  persistReducer(config, rootReducer),

const persistStoreEnhancer = createStore => (...args) => {
  const store = createStore(...args);
  storePersistor = persistStore(
    store,
    {
      storage: AsyncStorage, // Use RN storage system
      transforms: [createTransform(toSerializableFormat, fromSerializableFormat)],
    }
  );
  return store;
};

export default async function testConfigureStore() {
    const storageTransform = createTransform(
      () => ({}),
      () => ({})
    );

    const offlineConfig = {
        detectNetwork: () => true,
        persist: (store, options) => {
            return persistStore(store, {storage: new AsyncNodeStorage('./.tmp'), ...options});
        },
        persistOptions: {
            debounce: 1000,
            transforms: [
                storageTransform
            ]
        }
    };

const createExchangeTransform = () =>
  createTransform((inboundState, key) => {
    if (key === 'exchanges') {
      return _.mapValues(inboundState, object => _.omit(object, 'openRequests'));
    }
    return inboundState;
  }, _.identity);

export default function configureStore(initialState) {
    const setTransformer = createTransform(
        (inboundState, key) => {
            if (key === 'entities') {
                const state = {...inboundState};
                for (const prop in state) {
                    if (state.hasOwnProperty(prop)) {
                        state[prop] = transformSet(state[prop], setTransforms);
                    }
                }

                return state;
            }

            return inboundState;
        },
        (outboundState, key) => {
            if (key === 'entities') {

paths.forEach(([feature, props]) => {
  whitelist.push(feature);
  if (!props) return;
  const inOut = state => pick(props, state);
  transforms.push(createTransform(inOut, inOut, { whitelist: [feature] }));
});

if (err) reject(err);
            else {
                somethingRead = true;
                LAST_STATE[id] = stateNew[id] = { data:value };
                resolve();
            }
        }) );
    });


    await Promise.all(reads);

    return somethingRead ? { ...LAST_STATE } : state;
}

export default createTransform(
    inbound,
    outbound,
    { whitelist:['files'] }
)

import { createStore, applyMiddleware, compose } from 'redux';
import createSagaMiddleware from 'redux-saga';
import invariant from 'redux-immutable-state-invariant';
import { persistStore, persistReducer, createTransform } from 'redux-persist';
import autoMergeLevel2 from 'redux-persist/lib/stateReconciler/autoMergeLevel2';
import getStoredStateMigrateV4 from 'redux-persist/lib/integration/getStoredStateMigrateV4';
import applyAppStateListener from 'redux-enhancer-react-native-appstate';
import FileSystemStorage from 'redux-persist-filesystem-storage';
import AsyncStorage from '@react-native-community/async-storage';
import rootReducer from '../reducers';
import rootSaga from '../sagas';
import getStoredStateMigrateToFileSystemStorage from './getStoredStateMigrateToFileSystemStorage';

const myTransform = createTransform(
  (inboundState, key, state) => {
    switch (key) {
      case 'entities': {
        const {
          entities,
          browsingHistoryIllusts,
          browsingHistoryNovels,
          muteUsers,
        } = state;
        const selectedUsersEntities = {};
        const selectedIllustsEntities = browsingHistoryIllusts.items
          .filter(id => entities.illusts[id])
          .reduce((prev, id) => {
            prev[id] = entities.illusts[id];
            const userId = entities.illusts[id].user;
            selectedUsersEntities[userId] = entities.users[userId];