Make a module for runtime messages

src/Background.purs

@@ -4,25 +4,26 @@ import Prelude
 
 import Browser.WebExt.BrowserAction (onClickedAddListener)
 import Browser.WebExt.Listener (mkListener)
-import Browser.WebExt.Message (Message, mkMessage, displayMessage)
+import Browser.WebExt.Message (mkMessage)
 import Browser.WebExt.Runtime (onMessageAddListener)
 import Browser.WebExt.Tabs (Tab)
 import Browser.WebExt.Tabs as Tabs
 import Effect (Effect)
 import Effect.Class (class MonadEffect)
-import Effect.Class.Console (log)
+import Effect.Class.Console (log, logShow)
+import ExampleWebExt.RuntimeMessage (RuntimeMessage, mkRuntimeMessageHandler)
 
 main :: Effect Unit
 main = do
   log "[bg] starting up"
 
   onClickedAddListener $ mkListener browserActionOnClickedHandler
-  onMessageAddListener $ mkListener contentScriptMessageHandler
+  onMessageAddListener $ mkRuntimeMessageHandler contentScriptMessageHandler
 
 browserActionOnClickedHandler :: Tab -> Effect Unit
 browserActionOnClickedHandler tab = do
   _ <- Tabs.sendMessage tab.id $ mkMessage { clicked: tab.id }
   pure unit
 
-contentScriptMessageHandler ∷ ∀ m. MonadEffect m ⇒ Message → m Unit
-contentScriptMessageHandler m = log $ "[bg] received msg from content : " <> displayMessage m
+contentScriptMessageHandler ∷ ∀ m. MonadEffect m => RuntimeMessage → m Unit
+contentScriptMessageHandler m = logShow m

src/Content.purs

@@ -3,24 +3,26 @@ module ExampleWebExt.Content where
 import Prelude
 
 import Browser.DOM (getBrowserDom)
-import Browser.WebExt.Listener (mkListener)
-import Browser.WebExt.Message (Message, displayMessage, mkMessage)
-import Browser.WebExt.Runtime as Runtime
+import Data.Either (Either(..))
 import Effect (Effect)
 import Effect.Class.Console (logShow)
 import Effect.Console (log)
+import ExampleWebExt.RuntimeMessage (RuntimeMessage(..), sendMessageToBackground)
 import LinkedIn (extractFromDocument, getContext)
 
 main :: Effect Unit
 main = do
   log "[content] starting up"
 
-  Runtime.onMessageAddListener $ mkListener messageListener
-  _ <- Runtime.sendMessage $ mkMessage { simpleMessage: "hello from content" }
+  _ <- sendMessageToBackground RuntimeMessageContentInit
 
   dom <- getBrowserDom
   getContext dom >>= logShow
   extractFromDocument dom >>= logShow
 
-messageListener ∷ Message → Effect Unit
-messageListener m = log $ "[content] Received message " <> displayMessage m
+  ctx <- getContext dom
+  case ctx of
+    Right ctx' -> do
+      _ <- sendMessageToBackground $ RuntimeMessageContext ctx'
+      pure unit
+    Left _ -> log "Could not send context"

src/LinkedIn/PageUrl.purs

@@ -3,6 +3,8 @@ module LinkedIn.PageUrl (PageUrl(..), pageUrlP) where
 import Prelude
 
 import Control.Alt ((<|>))
+import Data.Argonaut.Decode (class DecodeJson)
+import Data.Argonaut.Decode.Generic (genericDecodeJson)
 import Data.Argonaut.Encode (class EncodeJson)
 import Data.Argonaut.Encode.Generic (genericEncodeJson)
 import Data.Generic.Rep (class Generic)
@@ -31,6 +33,7 @@ derive instance Eq PageUrl
 derive instance Generic PageUrl _
 instance Show PageUrl where show = genericShow
 instance EncodeJson PageUrl where encodeJson a = genericEncodeJson a
+instance DecodeJson PageUrl where decodeJson a = genericDecodeJson a
 
 pathComponentP :: String -> Parser String Unit
 pathComponentP s = do

src/LinkedIn/UI/Basic/Types.purs

@@ -2,10 +2,13 @@ module LinkedIn.UI.Basic.Types where
 
 import Prelude
 
+import Data.Argonaut.Decode (class DecodeJson, JsonDecodeError(..))
+import Data.Argonaut.Decode.Decoders (decodeNumber)
 import Data.Argonaut.Encode (class EncodeJson)
 import Data.Argonaut.Encode.Encoders (encodeNumber, encodeString)
 import Data.Argonaut.Encode.Generic (genericEncodeJson)
 import Data.Date (Month, Year)
+import Data.Either (note)
 import Data.Generic.Rep (class Generic)
 import Data.Int64 (Int64)
 import Data.Int64 as I64
@@ -18,6 +21,11 @@ derive instance Generic JobOfferId _
 instance Show JobOfferId where show = genericShow
 instance EncodeJson JobOfferId where
   encodeJson (JobOfferId a) = encodeNumber $ I64.toNumber a
+instance DecodeJson JobOfferId where
+  decodeJson json = do
+    nb <- decodeNumber json
+    i64 <- note (UnexpectedValue json) $ I64.fromNumber nb
+    pure $ JobOfferId i64
 
 data MonthYear = MonthYear Month Year
 

src/RuntimeMessage.purs

@@ -0,0 +1,44 @@
+module ExampleWebExt.RuntimeMessage where
+
+import Prelude
+
+import Browser.Runtime (Listener, mkListener)
+import Browser.WebExt.Message (Message, mkMessage, unwrapMessage)
+import Browser.WebExt.Runtime as Runtime
+import Data.Argonaut.Core (Json)
+import Data.Argonaut.Decode (class DecodeJson, printJsonDecodeError)
+import Data.Argonaut.Decode.Generic (genericDecodeJson)
+import Data.Argonaut.Encode (class EncodeJson)
+import Data.Argonaut.Encode.Generic (genericEncodeJson)
+import Data.Either (Either(..))
+import Data.Generic.Rep (class Generic)
+import Data.Show.Generic (genericShow)
+import Effect (Effect)
+import Effect.Class.Console (log)
+import LinkedIn.PageUrl (PageUrl)
+
+data RuntimeMessage =
+  RuntimeMessageContentInit
+  | RuntimeMessageContext PageUrl
+
+derive instance Generic RuntimeMessage _
+instance Show RuntimeMessage where show = genericShow
+instance EncodeJson RuntimeMessage where encodeJson a = genericEncodeJson a
+instance DecodeJson RuntimeMessage where decodeJson a = genericDecodeJson a
+
+sendMessageToBackground ∷ RuntimeMessage → Effect Unit
+sendMessageToBackground msg = do
+  _ <- Runtime.sendMessage $ mkMessage msg
+  pure unit
+
+decodeRuntimeMessage ∷ Message → Either String RuntimeMessage
+decodeRuntimeMessage m =
+  case unwrapMessage m of
+    Left err -> Left $ printJsonDecodeError err
+    Right m' -> Right m'
+
+mkRuntimeMessageHandler ∷ (RuntimeMessage → Effect Unit) → Listener Json
+mkRuntimeMessageHandler f = mkListener \m -> do
+  case decodeRuntimeMessage m of
+    Left err -> log err
+    Right m' -> f m'