7022713254

Committed 28 Nov 2023 06:06PM UTC coverage: 40.865%. Remained the same

Build # 7022713254

Build Type

Pull #2061

github

Committed by

web-flow

Commit Message

Merge f7103b09a into f9b03c5d7

Pull Request Pull Request #2061: fix: basepath for subdomains

Run Details

2271 of 6975 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 1 file covered. (50.0%)

15 existing lines in 1 file now uncovered.

4298 of 9100 relevant lines covered (47.23%)

18.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

25.0

/webapp/src/modules/store.ts

import { applyMiddleware, compose, createStore } from 'redux'
import createSagasMiddleware from 'redux-saga'
import { routerMiddleware } from 'connected-react-router'
import { createLogger } from 'redux-logger'
import { Env } from '@dcl/ui-env'
import { createStorageMiddleware } from 'decentraland-dapps/dist/modules/storage/middleware'
import { storageReducerWrapper } from 'decentraland-dapps/dist/modules/storage/reducer'
import { createTransactionMiddleware } from 'decentraland-dapps/dist/modules/transaction/middleware'
import { createAnalyticsMiddleware } from 'decentraland-dapps/dist/modules/analytics/middleware'
import { CLEAR_TRANSACTIONS } from 'decentraland-dapps/dist/modules/transaction/actions'

import { config } from '../config'
import { createRootReducer, RootState } from './reducer'
import { rootSaga } from './sagas'
import { fetchTilesRequest } from './tile/actions'
import { ARCHIVE_BID, UNARCHIVE_BID } from './bid/actions'
import { SET_IS_TRYING_ON } from './ui/preview/actions'
import { getCurrentIdentity } from './identity/selectors'
import { AuthIdentity } from 'decentraland-crypto-fetch'
import { createMemoryHistory, createBrowserHistory, History } from 'history'

export const createHistory = () =>
  createBrowserHistory({
    basename: /^decentraland.(zone|org|today)$/.test(window.location.host)
      ? '/marketplace'
      : undefined
  })

export function initStore(history: History) {
  const anyWindow = window as any

  const isDev = config.is(Env.DEVELOPMENT)

  const composeEnhancers =
    isDev && anyWindow.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
      ? anyWindow.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
          stateSanitizer: (state: RootState) => {
            const { tile, proximity, ...sanitized } = { ...state }
            return sanitized
          }
        })
      : compose

  const rootReducer = storageReducerWrapper(createRootReducer(history))

  const sagasMiddleware = createSagasMiddleware()
  const loggerMiddleware = createLogger({
    collapsed: () => true,
    predicate: (_: any, action) => isDev || action.type.includes('Failure')
  })
  const transactionMiddleware = createTransactionMiddleware()
  const { storageMiddleware, loadStorageMiddleware } = createStorageMiddleware({
    storageKey: 'marketplace-v2', // this is the key used to save the state in localStorage (required)
    paths: [
      ['ui', 'archivedBidIds'],
      ['ui', 'preview', 'isTryingOn']
    ], // array of paths from state to be persisted (optional)
    actions: [CLEAR_TRANSACTIONS, ARCHIVE_BID, UNARCHIVE_BID, SET_IS_TRYING_ON], // array of actions types that will trigger a SAVE (optional)
    migrations: {} // migration object that will migrate your localstorage (optional)
  })
  const analyticsMiddleware = createAnalyticsMiddleware(
    config.get('SEGMENT_API_KEY')!
  )

  const middleware = applyMiddleware(
    sagasMiddleware,
    routerMiddleware(history),
    loggerMiddleware,
    transactionMiddleware,
    storageMiddleware,
    analyticsMiddleware
  )
  const enhancer = composeEnhancers(middleware)
  const store = createStore(
    (rootReducer as unknown) as ReturnType<typeof createRootReducer>,
    enhancer
  )
  const getIdentity = () => {
    return (
      (getCurrentIdentity(store.getState()) as AuthIdentity | null) ?? undefined
    )
  }
  sagasMiddleware.run(rootSaga, getIdentity)
  loadStorageMiddleware(store)

  if (isDev) {
    const _window = window as any
    _window.getState = store.getState
  }

  // fetch tiles
  store.dispatch(fetchTilesRequest())

  return store
}

export function initTestStore(preloadedState = {}) {
  const testHistory = createMemoryHistory({ initialEntries: ['/marketplace'] })
  const rootReducer = storageReducerWrapper(createRootReducer(testHistory))
  const sagasMiddleware = createSagasMiddleware()
  const transactionMiddleware = createTransactionMiddleware()
  const { storageMiddleware, loadStorageMiddleware } = createStorageMiddleware({
    storageKey: 'marketplace-v2', // this is the key used to save the state in localStorage (required)
    paths: [
      ['ui', 'archivedBidIds'],
      ['ui', 'preview', 'isTryingOn']
    ], // array of paths from state to be persisted (optional)
    actions: [CLEAR_TRANSACTIONS, ARCHIVE_BID, UNARCHIVE_BID, SET_IS_TRYING_ON], // array of actions types that will trigger a SAVE (optional)
    migrations: {} // migration object that will migrate your localstorage (optional)
  })

  const middleware = applyMiddleware(
    sagasMiddleware,
    routerMiddleware(testHistory),
    transactionMiddleware,
    storageMiddleware
  )
  const enhancer = compose(middleware)
  const store = createStore(rootReducer, preloadedState, enhancer)
  sagasMiddleware.run(rootSaga, () => undefined)
  loadStorageMiddleware(store)
  store.dispatch(fetchTilesRequest())

  return store
}

1	import { applyMiddleware, compose, createStore } from 'redux'
2	import createSagasMiddleware from 'redux-saga'
3	import { routerMiddleware } from 'connected-react-router'
4	import { createLogger } from 'redux-logger'
5	import { Env } from '@dcl/ui-env'
6	import { createStorageMiddleware } from 'decentraland-dapps/dist/modules/storage/middleware'
7	import { storageReducerWrapper } from 'decentraland-dapps/dist/modules/storage/reducer'
8	import { createTransactionMiddleware } from 'decentraland-dapps/dist/modules/transaction/middleware'
9	import { createAnalyticsMiddleware } from 'decentraland-dapps/dist/modules/analytics/middleware'
10	import { CLEAR_TRANSACTIONS } from 'decentraland-dapps/dist/modules/transaction/actions'
11
12	import { config } from '../config'
13	import { createRootReducer, RootState } from './reducer'
14	import { rootSaga } from './sagas'
15	import { fetchTilesRequest } from './tile/actions'
16	import { ARCHIVE_BID, UNARCHIVE_BID } from './bid/actions'
17	import { SET_IS_TRYING_ON } from './ui/preview/actions'
18	import { getCurrentIdentity } from './identity/selectors'
19	import { AuthIdentity } from 'decentraland-crypto-fetch'
20	import { createMemoryHistory, createBrowserHistory, History } from 'history'
21
22	export const createHistory = () =>	21✔
NEW 23	createBrowserHistory({	×
24	basename: /^decentraland.(zone\|org\|today)$/.test(window.location.host)	×
25	? '/marketplace'
26	: undefined
27	})
28
29	export function initStore(history: History) {
UNCOV 30	const anyWindow = window as any	×
31
UNCOV 32	const isDev = config.is(Env.DEVELOPMENT)	×
33
34	const composeEnhancers =
UNCOV 35	isDev && anyWindow.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__	×
36	? anyWindow.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
37	stateSanitizer: (state: RootState) => {
38	const { tile, proximity, ...sanitized } = { ...state }	×
UNCOV 39	return sanitized	×
40	}
41	})
42	: compose
43
UNCOV 44	const rootReducer = storageReducerWrapper(createRootReducer(history))	×
45
46	const sagasMiddleware = createSagasMiddleware()	×
47	const loggerMiddleware = createLogger({	×
48	collapsed: () => true,	×
UNCOV 49	predicate: (_: any, action) => isDev \|\| action.type.includes('Failure')	×
50	})
51	const transactionMiddleware = createTransactionMiddleware()	×
UNCOV 52	const { storageMiddleware, loadStorageMiddleware } = createStorageMiddleware({	×
53	storageKey: 'marketplace-v2', // this is the key used to save the state in localStorage (required)
54	paths: [
55	['ui', 'archivedBidIds'],
56	['ui', 'preview', 'isTryingOn']
57	], // array of paths from state to be persisted (optional)
58	actions: [CLEAR_TRANSACTIONS, ARCHIVE_BID, UNARCHIVE_BID, SET_IS_TRYING_ON], // array of actions types that will trigger a SAVE (optional)
59	migrations: {} // migration object that will migrate your localstorage (optional)
60	})
UNCOV 61	const analyticsMiddleware = createAnalyticsMiddleware(	×
62	config.get('SEGMENT_API_KEY')!
63	)
64
UNCOV 65	const middleware = applyMiddleware(	×
66	sagasMiddleware,
67	routerMiddleware(history),
68	loggerMiddleware,
69	transactionMiddleware,
70	storageMiddleware,
71	analyticsMiddleware
72	)
73	const enhancer = composeEnhancers(middleware)	×
UNCOV 74	const store = createStore(	×
75	(rootReducer as unknown) as ReturnType<typeof createRootReducer>,
76	enhancer
77	)
78	const getIdentity = () => {	×
UNCOV 79	return (	×
80	(getCurrentIdentity(store.getState()) as AuthIdentity \| null) ?? undefined	×
81	)
82	}
83	sagasMiddleware.run(rootSaga, getIdentity)	×
UNCOV 84	loadStorageMiddleware(store)	×
85
86	if (isDev) {	×
87	const _window = window as any	×
UNCOV 88	_window.getState = store.getState	×
89	}
90
91	// fetch tiles
UNCOV 92	store.dispatch(fetchTilesRequest())	×
93
UNCOV 94	return store	×
95	}
96
97	export function initTestStore(preloadedState = {}) {	×
98	const testHistory = createMemoryHistory({ initialEntries: ['/marketplace'] })	172✔
99	const rootReducer = storageReducerWrapper(createRootReducer(testHistory))	172✔
100	const sagasMiddleware = createSagasMiddleware()	172✔
101	const transactionMiddleware = createTransactionMiddleware()	172✔
102	const { storageMiddleware, loadStorageMiddleware } = createStorageMiddleware({	172✔
103	storageKey: 'marketplace-v2', // this is the key used to save the state in localStorage (required)
104	paths: [
105	['ui', 'archivedBidIds'],
106	['ui', 'preview', 'isTryingOn']
107	], // array of paths from state to be persisted (optional)
108	actions: [CLEAR_TRANSACTIONS, ARCHIVE_BID, UNARCHIVE_BID, SET_IS_TRYING_ON], // array of actions types that will trigger a SAVE (optional)
109	migrations: {} // migration object that will migrate your localstorage (optional)
110	})
111
112	const middleware = applyMiddleware(	172✔
113	sagasMiddleware,
114	routerMiddleware(testHistory),
115	transactionMiddleware,
116	storageMiddleware
117	)
118	const enhancer = compose(middleware)	172✔
119	const store = createStore(rootReducer, preloadedState, enhancer)	172✔
120	sagasMiddleware.run(rootSaga, () => undefined)	172✔
121	loadStorageMiddleware(store)	172✔
122	store.dispatch(fetchTilesRequest())	172✔
123
124	return store	172✔
125	}

decentraland / marketplace / 7022713254

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous