/**
 * Combine all reducers in this file and export the combined reducers.
 */

import { combineReducers } from '@reduxjs/toolkit';
import { phoenixReducer } from '@trixtateam/phoenix-to-redux';
import { trixtaReducer } from '@trixtateam/trixta-js-core-core';
export default function createReducer() {
  const rootReducer = combineReducers({
    trixta: trixtaReducer,
    phoenix: phoenixReducer,
  });
  return rootReducer;
}

import { configureStore, getDefaultMiddleware } from '@reduxjs/toolkit';
import { createPhoenixChannelMiddleware } from '@trixtateam/phoenix-to-redux';
import createSagaMiddleware from 'redux-saga';
import { createReducer } from './reducers';

export default function configureStore() {
  const reduxSagaMonitorOptions = {};
  // Makes redux connected to phoenix channels
  const phoenixChannelMiddleWare = createPhoenixChannelMiddleware();
  const sagaMiddleware = createSagaMiddleware(reduxSagaMonitorOptions);
  // Create the store with saga middleware
  const middlewares = [sagaMiddleware,phoenixChannelMiddleWare];

   const enhancers = [];

  const store = configureStore({
    reducer: createReducer(),
    middleware: [
      ...getDefaultMiddleware({
        thunk: false,
        immutableCheck: {
          ignore: ['socket', 'channel', 'trixta', 'phoenix', 'router'],
        },
        serializableCheck: false,
      }),
      ...middlewares,
    ],
    devTools:
      /* istanbul ignore next line */
      process.env.NODE_ENV !== 'production' ||
      process.env.PUBLIC_URL.length > 0,
    enhancers,
  });

   return store;
}

import { configureStore, getDefaultMiddleware } from '@reduxjs/toolkit';
import { createPhoenixChannelMiddleware } from '@trixtateam/phoenix-to-redux';
import createSagaMiddleware from 'redux-saga';
import { setupTrixtaSaga } from '@trixtateam/trixta-js-core';
import createReducer from './reducers';

export default function configureStore() {
  const reduxSagaMonitorOptions = {};
  // Makes redux connected to phoenix channels
  const phoenixChannelMiddleWare = createPhoenixChannelMiddleware();
  const sagaMiddleware = createSagaMiddleware(reduxSagaMonitorOptions);
  const middlewares = [sagaMiddleware,phoenixChannelMiddleWare];

  const enhancers = [];

  const store = configureStore({
    reducer: createReducer(),
    middleware: [
      ...getDefaultMiddleware({
        thunk: false,
        immutableCheck: {
          ignore: ['socket', 'channel', 'trixta', 'phoenix', 'router'],
        },
        serializableCheck: false,
      }),
      ...middlewares,
    ],
    devTools:
      /* istanbul ignore next line */
      process.env.NODE_ENV !== 'production' ||
      process.env.PUBLIC_URL.length > 0,
    enhancers,
  });

  sagaMiddleware.run(setupTrixtaSaga);

  return store;
}

import { put, select, takeLatest, takeEvery, fork } from 'redux-saga/effects';
import { setupTrixtaSaga } from '@trixtateam/trixta-js-core';

export default function* rootSaga() {
  yield fork(setupTrixtaSaga);
}

import { configureStore, getDefaultMiddleware } from '@reduxjs/toolkit';
import { createPhoenixChannelMiddleware } from '@trixtateam/phoenix-to-redux';
import createSagaMiddleware from 'redux-saga';
import rootSaga from './rootSaga';
import createReducer from './reducers';

export default function configureStore() {
   const reduxSagaMonitorOptions = {};
  // Makes redux connected to phoenix channels
  const phoenixChannelMiddleWare = createPhoenixChannelMiddleware();
  const sagaMiddleware = createSagaMiddleware(reduxSagaMonitorOptions);
  const middlewares = [sagaMiddleware,phoenixChannelMiddleWare];

  const enhancers = [];

  const store = configureStore({
    reducer: createReducer(),
    middleware: [
      ...getDefaultMiddleware({
        thunk: false,
        immutableCheck: {
          ignore: ['socket', 'channel', 'trixta', 'phoenix', 'router'],
        },
        serializableCheck: false,
      }),
      ...middlewares,
    ],
    devTools:
      /* istanbul ignore next line */
      process.env.NODE_ENV !== 'production' ||
      process.env.PUBLIC_URL.length > 0,
    enhancers,
  });

  sagaMiddleware.run(rootSaga);

  return store;
}

import * as React from 'react';
import { useTrixtaSpace } from '@trixtateam/trixta-js-core';
import Providers from './Providers';
import Routes from './Routes';


export function App() {
   useTrixtaSpace({ space: 'trixta-demo.space.trixta.io', params: {}});
  
return (<Providers>
      <Routes />
    </Providers>)

}

export default App;

import { put, select, takeLatest, takeEvery, fork } from 'redux-saga/effects';
import { connectTrixta } from '@trixtateam/trixta-js-core';

export function* connectTrixtaSaga() {
  yield put(connectTrixta({ space: 'trixta-demo.space.trixta.io'}));
}

export default function* rootSaga() {
  yield fork(setupTrixtaSaga);
  yield call(connectTrixtaSaga);
}

import {
  removeTrixtaRole
} from '@trixtateam/trixta-js-core';

import {
  updateTrixtaRole
} from '@trixtateam/trixta-js-core';

import {
  updateTrixtaRoles
} from '@trixtateam/trixta-js-core';

import {
  TrixtaReactionComponent,
  TrixtaReactionComponentArgs
} from '@trixtateam/trixta-js-core';

<TrixtaReactionComponent
  roleName=""
  reactionName=""
  includeResponse={false}
  initialData={}
  extraData={}
  requestForEffect={false}
  defaultComponent={<Component/>}
  debugMode={false}
  requestEvent=""
  responseEvent=""
  errorEvent=""
  timeoutEvent=""
  timeout={1500}
  setTimeoutEventAsErrorEvent={false}
>
  {({
    submit,
    isInProgress,
    loading,
    instance,
    response,
    data,
  }: TrixtaReactionComponentArgs<
    TInitialData,TFormDataType,TSuccessType,TErrorType
  >) => (
    {function | <component />}
  )}
</TrixtaReactionComponent>

export function functionToDispatch(payload) {
  return {
    type: '',
    payload,
  }
}

import {
  RespondToReactionComponent,
} from '@trixtateam/trixta-js-core';

<RespondToReactionComponent
  roleName=""
  reactionName=""
  formData={}
  shouldRespond={false}
  actionToDispatch={functionToDispatch}
  dispatchResponseTo=""
  requestForEffect={false}
/>

export function functionToDispatch(payload) {
  return {
    type: '',
    payload,
  }
}

import {
  RespondToReactionsComponent,
} from '@trixtateam/trixta-js-core';

<RespondToReactionsComponent
  roleName=""
  reactions={[{name,actionToDispatch,dispatchResponseTo,requestForEffect}]}
/>

import {
  TrixtaReactionResponseComponent,
  TrixtaReactionComponentArgs
} from '@trixtateam/trixta-js-core';

<TrixtaReactionResponseComponent
  roleName=""
  reactionName=""
  debugMode={false}
>
  {({
    isInProgress,
    loading,
    instance,
    response,
    data,
  }: TrixtaReactionComponentArgs<
    TInitialData,TFormDataType,TSuccessType,TErrorType
  >) => (
    {function | <component />}
  )}
</TrixtaReactionResponseComponent>

import {
  TrixtaActionComponent,
  TrixtaActionComponentArgs
} from '@trixtateam/trixta-js-core';

<TrixtaActionComponent
  roleName=""
  actionName=""
  initialData={}
  extraData={}
  debugOptions={}
  debugMode={false}
  requestEvent=""
  responseEvent=""
  errorEvent=""
  timeoutEvent=""
  timeout={1500}
  setTimeoutEventAsErrorEvent={false}
  actionOptions={}
>
  {({
    submit,
    isInProgress,
    instances,
    response,
    initialData,
  }: TrixtaActionComponentArgs<
    TFormDataType,TSuccessType,TErrorType
  >) => (
    {function | <component />}
  )}
</TrixtaActionComponent>

import { useTrixtaActionReaction } from '@trixtateam/trixta-js-core';
const { 
hasRoleAccess,
initialData,
isInProgress,
hasResponse,
hasActionResponse,
hasReactionResponse,
loading,
actionResponse,
reactionResponse,
submitTrixtaActionResponse,
submitTrixtaReactionResponse,
clearActionResponses,
clearReactionResponses,
} = useTrixtaActionReaction<TInitialData,
TActionResponseType,
TActionErrorType,
TReactionResponseType,
TReactionErrorType
>({ 
  actionProps:{
    roleName:"",
    actionName:"",
  },
  reactionProps:{
    roleName:"",
    reactionName:"",
  },
  autoSubmit:false,
  actionParameters:{
    data:{},
    extraData:{},
    timeout:1500,
    timeoutEvent:"",
    loadingStatusRef:"",
    requestEvent:"",
    responseEvent:"",
    errorEvent:""
  }
   });

import { useTrixtaAction } from '@trixtateam/trixta-js-core';
const { 
hasRoleAccess,
isInProgress,
hasResponse,
loading,
latestInstance,
response,
submitTrixtaAction,
clearActionResponses,
} = useTrixtaAction<TSuccessType,TErrorType>({ roleName:"",
  actionName:"",
  actionParameters:{
    data:{},
    extraData:{},
    timeout:1500,
    timeoutEvent:"",
    loadingStatusRef:"",
    requestEvent:"",
    responseEvent:"",
    errorEvent:""
  },
  loadingStatusRef:"",
  options: {
    debugMode: false,
    autoSubmit: false,
    setTimeoutEventAsErrorEvent: false,
    clearResponsesOnCallback: false,
  },
  onSuccess:(success)=>{},
  onError:(errror)=>{}
   });

import { useRespondToReactionResponse } from '@trixtateam/trixta-js-core';
const { 
hasRoleAccess,
latestInstance,
respondToReaction
} = useRespondToReactionResponse<TInitialData>({ 
  roleName:"",
  reactionName:"",
  debugMode: false,
   });

import { useTrixtaRoles } from '@trixtateam/trixta-js-core';
useTrixtaRoles({ roles });