Remove use of Signal to allow the user to hook in their preferred state management (#3)

* Removed Wire as a dependency

* Remove the Interface alias

Author: robertdp

examples/RoutingDuplex.purs

@@ -1,12 +1,15 @@
 {-| This example also requires the following dependencies to be installed:
     - react-basic-dom
     - routing-duplex
+    - wire
     - wire-react
 -}
 module Example.RoutingDuplex where
 
 import Prelude hiding ((/))
+import Data.Foldable (for_)
 import Data.Generic.Rep (class Generic)
+import Data.Lens (preview, review)
 import Data.Lens as Lens
 import Effect (Effect)
 import React.Basic.DOM as R
@@ -18,7 +21,6 @@ import Routing.Duplex.Generic (noArgs, sum)
 import Routing.Duplex.Generic.Syntax ((/))
 import Routing.PushState as PushState
 import Wire.React as Wire
-import Wire.React.Router (_Route)
 import Wire.React.Router as Router
 
 data Route
@@ -41,27 +43,29 @@ routes =
 makeApp :: Effect (Unit -> JSX)
 makeApp = do
   interface <- PushState.makeInterface
+  { signal: routeSignal, modify: modifyRouteSignal } <- Signal.create NotFound
   router <-
     Router.makeRouter interface
-      { fallback:
-          -- used as the initial route if the parser fails
-          NotFound
-      , parse: parse routes
+      { parse: parse routes
       , print: print routes
       , onRoute:
           -- this skips any async routing logic by accepting the parsed route immediately
-          \route -> Router.continue
+          const Router.continue
+      , onTransition:
+          case _ of
+            Router.Transitioning _ _ -> pure unit
+            Router.Resolved _ route -> modifyRouteSignal (const route)
       }
   React.component "App" \props -> React.do
     route <-
       -- subscribe to the signal containing the current route
-      Wire.useSignal router.signal
+      Wire.useSignal routeSignal
     pure
       $ React.fragment
           [ -- the router subscribes to pushstate events when this component is mounted, and unsubscribes when unmounted
             router.component
           , R.h1_
-              [ R.text case Lens.view _Route route of
+              [ R.text case route of
                   Home -> "Home"
                   About -> "About"
                   NotFound -> "Not Found"

packages.dhall

@@ -123,12 +123,6 @@ let upstream =
 
 let overrides = {=}
 
-let additions =
-  { wire =
-    { dependencies = [ "aff", "filterable", "refs", "unsafe-reference" ]
-    , repo = "https://github.com/robertdp/purescript-wire.git"
-    , version = "v0.4.2"
-    }
-  }
+let additions = {=}
 
 in  upstream // overrides // additions

spago.dhall

@@ -10,7 +10,6 @@ You can edit this file as you like.
   , "profunctor-lenses"
   , "react-basic-hooks"
   , "routing"
-  , "wire"
   ]
 , packages = ./packages.dhall
 , sources = [ "src/**/*.purs", "test/**/*.purs" ]

src/Router.purs

@@ -16,29 +16,24 @@ import React.Basic.Hooks (JSX)
 import React.Basic.Hooks as React
 import Routing.PushState (PushStateInterface)
 import Routing.PushState as PushState
-import Wire.React.Router.Control (Command(..), Resolved, Route(..), Router(..), Transitioning)
-import Wire.React.Router.Control (Command, Resolved, Route(..), Router, Transitioning, _Resolved, _Route, _Transitioning, continue, isResolved, isTransitioning, override, redirect) as Control
-import Wire.Signal (Signal)
-import Wire.Signal as Signal
-
-type Interface route
-  = { signal :: Signal (Route route)
-    , component :: JSX
-    , navigate :: route -> Effect Unit
-    , redirect :: route -> Effect Unit
-    }
+import Wire.React.Router.Control (Command(..), Resolved, Router(..), Transition(..), Transitioning)
+import Wire.React.Router.Control (Command, Resolved, Router, Transition(..), Transitioning, _Resolved, _Transition, _Transitioning, continue, isResolved, isTransitioning, override, redirect) as Control
 
 makeRouter ::
   forall f route.
   Foldable f =>
   PushStateInterface ->
-  { fallback :: route
-  , parse :: String -> f route
+  { parse :: String -> f route
   , print :: route -> String
   , onRoute :: route -> Router route Transitioning Resolved Unit
+  , onTransition :: Transition route -> Effect Unit
   } ->
-  Effect (Interface route)
-makeRouter interface { fallback, parse, print, onRoute } =
+  Effect
+    { component :: JSX
+    , navigate :: route -> Effect Unit
+    , redirect :: route -> Effect Unit
+    }
+makeRouter interface { parse, print, onRoute, onTransition } =
   let
     onPushState k = PushState.matchesWith parse (\_ -> k) interface
 
@@ -47,11 +42,9 @@ makeRouter interface { fallback, parse, print, onRoute } =
     redirect route = interface.replaceState (unsafeToForeign {}) (print route)
   in
     do
-      { modify, signal } <- Signal.create (Transitioning Nothing fallback)
-      do
-        -- replace the user-supplied fallback route with the current route, if possible
-        { path } <- interface.locationState
-        for_ (parse path) \route -> modify \_ -> Transitioning Nothing route
+      -- replace the user-supplied fallback route with the current route, if possible
+      { path } <- interface.locationState
+      for_ (parse path) \route -> onTransition $ Transitioning Nothing route
       fiberRef <- Ref.new Nothing
       previousRouteRef <- Ref.new Nothing
       let
@@ -62,12 +55,12 @@ makeRouter interface { fallback, parse, print, onRoute } =
             for_ oldFiber \fiber -> launchAff_ (killFiber (error "Transition cancelled") fiber)
           previousRoute <- Ref.read previousRouteRef
           -- set the route state to "transitioning" with the previous successful route
-          modify \_ -> Transitioning previousRoute route
+          onTransition $ Transitioning previousRoute route
           let
             finalise r =
               liftEffect do
                 Ref.write (Just r) previousRouteRef
-                modify \_ -> Resolved previousRoute r
+                onTransition $ Resolved previousRoute r
           fiber <-
             launchAff case onRoute route of
               Router router ->
@@ -84,4 +77,4 @@ makeRouter interface { fallback, parse, print, onRoute } =
         React.component "Wire.Router" \_ -> React.do
           React.useEffectOnce (onPushState runRouter)
           pure React.empty
-      pure { signal, component: component unit, navigate, redirect }
+      pure { component: component unit, navigate, redirect }

src/Router/Control.purs

@@ -11,14 +11,14 @@ import Effect.Aff.Class (class MonadAff, liftAff)
 import Effect.Class (class MonadEffect, liftEffect)
 import Type.Equality (class TypeEquals)
 
-data Route route
+data Transition route
   = Transitioning (Maybe route) route
   | Resolved (Maybe route) route
 
-derive instance eqRoute :: Eq route => Eq (Route route)
+derive instance eqRoute :: Eq route => Eq (Transition route)
 
-_Route :: forall route. Lens' (Route route) route
-_Route = lens getter setter
+_Transition :: forall route. Lens' (Transition route) route
+_Transition = lens getter setter
   where
   getter = case _ of
     Transitioning _ route -> route
@@ -28,22 +28,22 @@ _Route = lens getter setter
     Transitioning route _ -> Transitioning route
     Resolved route _ -> Resolved route
 
-_Transitioning :: forall route. Prism' (Route route) route
+_Transitioning :: forall route. Prism' (Transition route) route
 _Transitioning =
   prism' (Transitioning Nothing) case _ of
     Transitioning _ route -> Just route
     _ -> Nothing
 
-_Resolved :: forall route. Prism' (Route route) route
+_Resolved :: forall route. Prism' (Transition route) route
 _Resolved =
   prism' (Resolved Nothing) case _ of
     Resolved _ route -> Just route
     _ -> Nothing
 
-isTransitioning :: forall route. Route route -> Boolean
+isTransitioning :: forall route. Transition route -> Boolean
 isTransitioning = is _Transitioning
 
-isResolved :: forall route. Route route -> Boolean
+isResolved :: forall route. Transition route -> Boolean
 isResolved = is _Resolved
 
 data Command route a