React.Router

newtype Location

RouterState type

newtype LinkProps eff

Constructors

• LinkProps { action :: Eff (props :: ReactProps, refs :: ReactRefs ReadOnly, state :: ReactState ReadWrite | eff) Unit, props :: Array Props, url :: URL }

newtype BrowserRouter props arg notFoundProps

BrowserRouter prop type

Constructors

• BrowserRouter { config :: RouterConfig, notFound :: Maybe { cls :: ReactClass notFoundProps, props :: notFoundProps }, router :: Cofree List (Tuple (Route props arg) (Maybe (IndexRoute props arg))) }

linkSpec :: forall eff. ReactSpec (LinkProps eff) Unit ()

ReactSpec for the link element; it takes a record of type LinkProps as properties. The props record property is directly passed to underlying a element, e.g. this can be used to add css classes.

linkClass :: forall eff. ReactClass (LinkProps eff)

React class for the link element.

link' :: RouterConfig -> URL -> Array ReactElement -> ReactElement

as link, but with empty props.

link :: RouterConfig -> URL -> Array Props -> Array ReactElement -> ReactElement

link element; use it instead of a to route the user through application with the default action goto cfg url and custom properties.

goto :: forall eff. RouterConfig -> URL -> Eff (console :: CONSOLE, dom :: DOM, history :: HISTORY | eff) Unit

goto url

browserRouterClass :: forall notfound arg props. RoutePropsClass props arg => ReactClass (BrowserRouter props arg notfound)

React class for the browerRouter element. Use it to init your application.

 router = ... :: Router _
 main = void $ elm >>= render (createElement browserRouterClass {router, notFound: Nothing} [])
   where
     elm = do
       elm_ <- window >>= document >>= getElementById (ElementId "app") <<< documentToNonElementParentNode <<< htmlDocumentToDocument
       pure $ unsafePartial fromJust (toMaybe elm_)
 ```

browserRouter :: forall notfound arg props eff. RoutePropsClass props arg => ReactSpec (BrowserRouter props arg notfound) Location (console :: CONSOLE, dom :: DOM, history :: HISTORY | eff)

ReactSpec for the browserRouterClass - the main entry point react class for the router.

newtype LeafVal props arg

Constructors

• LeafVal { arg :: arg, indexRoute :: Maybe (IndexRoute props arg), open :: Boolean, route :: Route props arg, url :: Route }

Instances

• Newtype (LeafVal props arg) _

runRouter' :: forall arg props. RoutePropsClass props arg => Route -> Cofree List (Tuple (Route props arg) (Maybe (IndexRoute props arg))) -> Maybe ReactElement

runRouter :: forall arg props. RoutePropsClass props arg => URL -> Cofree List (Tuple (Route props arg) (Maybe (IndexRoute props arg))) -> Maybe ReactElement

Main entry point for running Router, it returns ReactElement that can be injected into React vDOM.

matchRouter :: forall arg props. RoutePropsClass props arg => Route -> Router props arg -> Maybe (Cofree List (LeafVal props arg))

newtype RouterConfig

Constructors

• RouterConfig { baseName :: Maybe URL }

Instances

• Newtype RouterConfig _

type Router props arg = RoutePropsClass props arg => Cofree List ((Route props arg) /\ (Maybe (IndexRoute props arg)))

Router

router :: Router RouteProps Unit
router =
  Route "main" (unit <$ lit "") mainClass :+
    (Route "home" (unit <$ lit "home") homeClass :+ Nil)
    : (Tuple (Route "user" (unit <$ (lit "user" *> int)) userClass) (Just $ IndexRoute "user-index" userIndexClass) :<
        (Route "book" (unit <$ (lit "books" *> int)) bookClass :+
          (Route "pages" (unit <$ lit "pages") pagesClass :+
            (Route "page" (unit <$ int) pageClass :+ Nil)
            : Nil)
          : Nil)
        : Nil)
    : (Route "user-settings" (unit <$ (lit "user" *> int *> lit "settings")) settingsClass :+ Nil)
    : Nil

newtype RouteProps arg

RouteProps type keeps track route related data: id, currently matched argument and array of arguments - if the route is nested this will hold list of all parent arguments.

Constructors

• RouteProps { arg :: arg, args :: List arg, id :: String, query :: Map String String, tail :: List (Cofree List (RouteLeaf arg)), url :: Route }

Instances

• (Eq arg) => Eq (RouteProps arg)
• RoutePropsClass RouteProps arg
• Newtype (RouteProps arg) _

newtype RouteLeaf arg

Constructors

• RouteLeaf { arg :: arg, url :: Route }

Instances

• (Eq arg) => Eq (RouteLeaf arg)
• Newtype (RouteLeaf arg) _

type RouteClass props arg = RoutePropsClass props arg => ReactClass (props arg)

React component which will be mounted at matching node It recieves array of all matching routes.

data Route props arg

Route type The first parameter is an identifier.

Constructors

• Route String (Match arg) (RouteClass props arg)
• OpenRoute String (Match arg) (RouteClass props arg)

Instances

• Show (Route props arg)

data IndexRoute props arg

IndexRoute type The first parameter is the id property.

Constructors

• IndexRoute String (RouteClass props arg)

class RoutePropsClass props arg | props -> arg where

The RoutePropsClass type class let one extend the properties passed to each RouteClass react class component. There is one instance RouteProps defined in the React.Router.Type module. The mkProps member function receives the name of the route and an nonempty array of args read from the url. You can use React.Router.Utils.last function to get the last element of the array with arguments obtained from the corrsponding url part.

Members

• idLens :: Lens' (props arg) String
• mkProps :: String -> arg -> List arg -> Map String String -> List (Cofree List (RouteLeaf arg)) -> Route -> props arg

Instances

• RoutePropsClass RouteProps arg

withoutIndex :: forall arg props. RoutePropsClass props arg => Route props arg -> List (Cofree List ((Route props arg) /\ (Maybe (IndexRoute props arg)))) -> Cofree List ((Route props arg) /\ (Maybe (IndexRoute props arg)))

defaultConfig :: RouterConfig

_url :: forall arg props. Route props arg -> Match arg

_id :: forall arg props. Route props arg -> String

_cls :: forall arg props. RoutePropsClass props arg => (Route props arg) -> (RouteClass props arg)

Operator alias for React.Router.Types.withoutIndex (right-associative / precedence 5)

:+ lets define routes without index route