How to use found - 10 common examples

to: '/foo',
      }),
    ],
  },
];

const store = createStore(
  combineReducers({
    found: foundReducer,
  }),
  compose(
    createHistoryEnhancer({
      protocol: new BrowserProtocol(),
      middlewares: [queryMiddleware],
    }),
    createMatchEnhancer(new Matcher(routeConfig)),
  ),
);

store.dispatch(FarceActions.init());

const ConnectedRouter = createConnectedRouter({
  render: createRender({
    /* eslint-disable react/prop-types */
    renderError: ({ error }) => (
      <div>{error.status === 404 ? 'Not found' : 'Error'}</div>
    ),
    /* eslint-enable react/prop-types */
  }),
});

ReactDOM.render(

const store = createStore(
  combineReducers({
    found: foundReducer,
  }),
  compose(
    createHistoryEnhancer({
      protocol: new BrowserProtocol(),
      middlewares: [queryMiddleware],
    }),
    createMatchEnhancer(new Matcher(routeConfig)),
  ),
);

store.dispatch(FarceActions.init());

const ConnectedRouter = createConnectedRouter({
  render: createRender({
    /* eslint-disable react/prop-types */
    renderError: ({ error }) => (
      <div>{error.status === 404 ? 'Not found' : 'Error'}</div>
    ),
    /* eslint-enable react/prop-types */
  }),
});

ReactDOM.render(
  
    
  ,
  document.getElementById('root'),
);

(async () => {
  const BrowserRouter = await createInitialBrowserRouter({
    routeConfig,
    render: createRender({
      renderError: (
        { error }, // eslint-disable-line react/prop-types
      ) =&gt; <div>{error.status === 404 ? 'Not found' : 'Error'}</div>,
    }),
  });

  hydrate(, document.getElementById('reactDiv'));
})();

export async function mountClient(routeConfig) {
  const environment = createRelayEnvironment(
    JSON.parse(window.__RELAY_BOOTSTRAP__)
  ) // eslint-disable-line
  const historyMiddlewares = [queryMiddleware]
  const resolver = new Resolver(environment)
  const render = createRender({})

  try {
    const Router = await createInitialFarceRouter({
      historyProtocol: new BrowserProtocol(),
      historyMiddlewares,
      routeConfig,
      resolver,
      render,
    })

    Loadable.preloadReady().then(() => {
      ReactDOM.hydrate(

app.use(async (req, res) => {
  const {status, element} = await getFarceResult({
    url: req.url,
    routeConfig,
    render: createRender({
      renderError: (
        { error }, // eslint-disable-line react/prop-types
      ) =&gt; <div>{error.status === 404 ? 'Not found' : 'Error'}</div>,
    }),
  });
  const htmlString = `
    
         
            <title>Relay Modern SSR</title>
            
            
          
          
            <div id="reactDiv">${renderToString(element)}</div>
            

import { Environment, Network, RecordSource, Store } from 'relay-runtime'
import { setEnviroment } from 'relay-compose'

import { ClientFetcher } from '../fetcher'

export function createResolver(fetcher) {
  const environment = new Environment({
    network: Network.create((...args) => fetcher.fetch(...args)),
    store: new Store(new RecordSource()),
  })

  setEnviroment(environment)
  return new Resolver(environment)
}

export const render = createRender({})

export function createClientResolver() {
  // eslint-disable-next-line no-underscore-dangle, no-undef
  const fetcher = new ClientFetcher(process.env.GRAPHQL_ENDPOINT, window.__RELAY_PAYLOADS__)
  return createResolver(fetcher)
}

export function createClientRouter() {
  return createConnectedRouter({ render })
}

/>
     import(/* webpackChunkName: "page" */ './Page'))}
      query={PageQuery}
      render={renderProp}
    />
     import(/* webpackChunkName: "home" */ './Home'))}
      query={HomeQuery}
      render={renderProp}
    />
  
);

export const render = createRender({});

import ContentNode from 'components/ContentNode';
import { dateRegex } from 'utils/regex';
import type { Post as PostType } from 'relay-wordpress';
import PostLink from './PostLink';

type PostProps = {
  post: PostType,
};

/* eslint-disable react/no-danger */

class Post extends React.Component {
  props: PostProps;

  static contextTypes = {
    router: routerShape.isRequired,
  };

  onEmbedClick = () => (e: Event) => {
    e.preventDefault();

    const { id, date } = this.props.post;
    const [, year, month, day] = dateRegex.exec(date);
    const url = `/${year}/${month}/${day}/${id}`;

    this.context.router.push(url);
  };

  render() {
    const { content: { data: content }, excerpt, featuredMedia } = this.props.post;
    const isEmbed = content && content.length && content[0].__typename === 'Embed';

});

export const historyMiddlewares = [queryMiddleware];

const renderProp = ({ Component, props }: { Component: any, props: Object }) =>
  Component && props ? (
    
      
    
  ) : (
    
  );

/* eslint-disable global-require */

export const routeConfig = makeRouteConfig(
   import(/* webpackChunkName: "app" */ '../containers/App'))}
    query={AppQuery}
    prepareVariables={params => ({
      ...params,
      menuID: 'TmF2TWVudToy',
      sidebarID: 'U2lkZWJhcjpzaWRlYmFyLTE=',
    })}
  >
     import(/* webpackChunkName: "term" */ './Term'))}
      query={TermQuery}
      render={renderProp}
      prepareVariables={params => ({

const middlewares = [
		queryMiddleware
	]
	if (options.basename) {
		middlewares.push(createBasenameMiddleware({
			basename: options.basename
		}))
	}
	return [
		createHistoryEnhancer({
			protocol: createHistoryProtocol(),
			middlewares
		}),
		createMatchEnhancer(
			// new Matcher(hotRouteConfig(routes))
			new Matcher(routes)
		)
	]
}