purescript_linked_in/src/LinkedIn/UI/Components/ArtDeco.purs

module LinkedIn.UI.Components.ArtDeco where

import Prelude

import Data.Foldable (class Foldable, foldMap, foldlDefault, foldrDefault)
import Data.Generic.Rep (class Generic)
import Data.Lens (Lens', Traversal', lens', traversed)
import Data.Lens.Record (prop)
import Data.List.NonEmpty (NonEmptyList)
import Data.Maybe (Maybe)
import Data.Show.Generic (genericShow)
import Data.Traversable (class Traversable, sequence, traverseDefault)
import Data.Tuple (Tuple(..))
import LinkedIn.CanBeQueried (class CanBeQueried)
import LinkedIn.QueryRunner (QueryRunner', ignoreNotFound, queryAll, queryOne, subQueryMany, subQueryOne)
import LinkedIn.Queryable (class Queryable)
import Type.Proxy (Proxy(..))
import Web.DOM (Node)


data ArtDecoPvsEntity a = ArtDecoPvsEntity {
  side :: Unit,
  center :: ArtDecoCenter a
}

data ArtDecoCenter a = ArtDecoCenter {
  header :: ArtDecoCenterHeader a,
  content :: ArtDecoCenterContent a
}

data ArtDecoCenterHeader a = ArtDecoCenterHeader {
  bold :: a,
  normal :: Maybe a,
  light :: Maybe (NonEmptyList a)
}

data ArtDecoCenterContent a = ArtDecoCenterContent (NonEmptyList (ArtDecoPvsEntitySubComponent a))

data ArtDecoPvsEntitySubComponent a = ArtDecoPvsEntitySubComponent (Maybe a)


derive instance Generic (ArtDecoPvsEntitySubComponent a) _
derive instance Eq a => Eq (ArtDecoPvsEntitySubComponent a)
instance Show a => Show (ArtDecoPvsEntitySubComponent a) where
  show = genericShow
derive instance Functor ArtDecoPvsEntitySubComponent

instance Foldable ArtDecoPvsEntitySubComponent where
  foldMap f (ArtDecoPvsEntitySubComponent sc) = foldMap f sc

  foldl = \x -> foldlDefault x
  foldr = \x -> foldrDefault x

instance Traversable ArtDecoPvsEntitySubComponent where
  sequence (ArtDecoPvsEntitySubComponent subComponents) = ado
    sc <- sequence subComponents
  in ArtDecoPvsEntitySubComponent sc

  traverse = \x -> traverseDefault x

instance Queryable q => CanBeQueried q ArtDecoPvsEntitySubComponent where
  query = queryArtDecoPvsEntitySubComponent

derive instance Generic (ArtDecoCenterContent a) _
derive instance Eq a => Eq(ArtDecoCenterContent a)
instance Show a => Show(ArtDecoCenterContent a) where
  show = genericShow
derive instance Functor ArtDecoCenterContent

instance Foldable ArtDecoCenterContent where
  foldMap f (ArtDecoCenterContent c) = foldMap (foldMap f) c

  foldl = \x -> foldlDefault x
  foldr = \x -> foldrDefault x

instance Traversable ArtDecoCenterContent where
  sequence (ArtDecoCenterContent center) = ado
    c <- sequence (map sequence center)
  in ArtDecoCenterContent c

  traverse = \x -> traverseDefault x

instance Queryable q => CanBeQueried q ArtDecoCenterContent where
  query = queryArtDecoCenterContent

derive instance Generic (ArtDecoCenterHeader a) _
derive instance Eq a => Eq(ArtDecoCenterHeader a)
instance Show a => Show(ArtDecoCenterHeader a) where
  show = genericShow
derive instance Functor ArtDecoCenterHeader

instance Foldable ArtDecoCenterHeader where
  foldMap f (ArtDecoCenterHeader {bold, normal, light}) = f bold <> foldMap f normal <> foldMap (foldMap f) light

  foldl = \x -> foldlDefault x
  foldr = \x -> foldrDefault x

instance Traversable ArtDecoCenterHeader where
  sequence (ArtDecoCenterHeader {bold, normal, light}) = ado
    b <- bold
    n <- sequence normal
    l <- sequence (map sequence light)
  in ArtDecoCenterHeader {bold: b, normal: n, light: l}

  traverse = \x -> traverseDefault x

instance Queryable q => CanBeQueried q ArtDecoCenterHeader where
  query = queryArtDecoCenterHeader

derive instance Generic (ArtDecoCenter a) _
derive instance Eq a => Eq(ArtDecoCenter a)
instance Show a => Show(ArtDecoCenter a) where
  show = genericShow
derive instance Functor ArtDecoCenter

instance Foldable ArtDecoCenter where
  foldMap f (ArtDecoCenter {header, content}) = foldMap f header <> foldMap f content

  foldl = \x -> foldlDefault x
  foldr = \x -> foldrDefault x

instance Traversable ArtDecoCenter where
  sequence (ArtDecoCenter {header, content}) = ado
    h <- sequence header
    c <- sequence content
  in ArtDecoCenter {header: h, content: c}

  traverse = \x -> traverseDefault x

instance Queryable q => CanBeQueried q ArtDecoCenter where
  query = queryArtDecoCenter

derive instance Generic (ArtDecoPvsEntity a) _
derive instance Eq a => Eq(ArtDecoPvsEntity a)
instance Show a => Show(ArtDecoPvsEntity a) where
  show = genericShow
derive instance Functor ArtDecoPvsEntity

instance Foldable ArtDecoPvsEntity where
  foldMap f (ArtDecoPvsEntity {side: _, center}) = foldMap f center

  foldl = \x -> foldlDefault x
  foldr = \x -> foldrDefault x

instance Traversable ArtDecoPvsEntity where
  sequence (ArtDecoPvsEntity {side, center}) = ado
    s <- pure side
    c <- sequence center
  in ArtDecoPvsEntity {side: s, center: c}

  traverse = \x -> traverseDefault x

instance Queryable q => CanBeQueried q ArtDecoPvsEntity where
  query = queryArtDecoPvsEntity

queryArtDecoPvsEntitySubComponent ∷ forall q. Queryable q=> QueryRunner' q (ArtDecoPvsEntitySubComponent Node)
queryArtDecoPvsEntitySubComponent n = do
  content <- ignoreNotFound $ queryOne "span[aria-hidden=true]" n
  pure $ ArtDecoPvsEntitySubComponent content

queryArtDecoCenterContent :: forall q. Queryable q => QueryRunner' q (ArtDecoCenterContent Node)
queryArtDecoCenterContent n = do
  sc <- subQueryMany queryArtDecoPvsEntitySubComponent ":scope > ul > li" n
  pure $ ArtDecoCenterContent sc

queryArtDecoCenterHeader :: forall q. Queryable q => QueryRunner' q (ArtDecoCenterHeader Node)
queryArtDecoCenterHeader n = do
  bold <- queryOne ":scope div.t-bold > span[aria-hidden=true]" n
  normal <-
    ignoreNotFound $
    queryOne ":scope span.t-normal:not(t-black--light) > span[aria-hidden=true]" n
  light <-
    ignoreNotFound $
    queryAll ":scope span.t-black--light > span[aria-hidden=true]" n

  pure $ ArtDecoCenterHeader {bold, normal, light}

queryArtDecoCenter :: forall q. Queryable q => QueryRunner' q (ArtDecoCenter Node)
queryArtDecoCenter n = do
  header <- subQueryOne queryArtDecoCenterHeader ":scope > div" n
  content <- subQueryOne queryArtDecoCenterContent ":scope > div.pvs-entity__sub-components" n

  pure $ ArtDecoCenter {header, content}

queryArtDecoPvsEntity :: forall q. Queryable q => QueryRunner' q (ArtDecoPvsEntity Node)
queryArtDecoPvsEntity n = do
  center <- subQueryOne queryArtDecoCenter ":scope > div.display-flex" n
  pure $ ArtDecoPvsEntity {side: unit, center}

_pvs_entity :: forall a. Lens' (ArtDecoPvsEntity a) { center ∷ ArtDecoCenter a , side ∷ Unit }
_pvs_entity = lens'
  \(ArtDecoPvsEntity pvs) -> Tuple pvs \pvs' -> ArtDecoPvsEntity pvs'

_center :: forall a. Lens' (ArtDecoCenter a) { content ∷ ArtDecoCenterContent a , header ∷ ArtDecoCenterHeader a }
_center = lens'
  \(ArtDecoCenter center) -> Tuple center \center' -> ArtDecoCenter center'

_header :: forall a. Lens' (ArtDecoCenterHeader a) { bold ∷ a , light ∷ Maybe (NonEmptyList a) , normal ∷ Maybe a }
_header = lens' \(ArtDecoCenterHeader h) -> Tuple h \h' -> ArtDecoCenterHeader h'

_content :: forall a. Lens' (ArtDecoCenterContent a) (NonEmptyList (ArtDecoPvsEntitySubComponent a))
_content = lens' \(ArtDecoCenterContent cs) -> Tuple cs \cs' -> ArtDecoCenterContent cs'

_sub_component :: forall a. Lens' (ArtDecoPvsEntitySubComponent a) (Maybe a)
_sub_component = lens' \(ArtDecoPvsEntitySubComponent s) -> Tuple s \s' -> ArtDecoPvsEntitySubComponent s'

_pvs_to_header :: forall a. Lens' (ArtDecoPvsEntity a) { bold ∷ a , light ∷ Maybe (NonEmptyList a) , normal ∷ Maybe a }
_pvs_to_header = _pvs_entity
  <<< prop (Proxy :: Proxy "center")
  <<< _center
  <<< prop (Proxy :: Proxy "header")
  <<< _header

_pvs_to_subcomponents ∷ ∀ a. Traversal' (ArtDecoPvsEntity a) (Maybe a)
_pvs_to_subcomponents = _pvs_entity
  <<< prop (Proxy :: Proxy "center")
  <<< _center
  <<< prop (Proxy :: Proxy "content")
  <<< _content
  <<< traversed
  <<< _sub_component

_pvs_to_header_bold :: forall a. Lens' (ArtDecoPvsEntity a) a
_pvs_to_header_bold = _pvs_to_header <<< prop (Proxy :: Proxy "bold")

_pvs_to_header_normal :: forall a. Lens' (ArtDecoPvsEntity a) (Maybe a)
_pvs_to_header_normal = _pvs_to_header <<< prop (Proxy :: Proxy "normal")

_pvs_to_header_light :: forall a. Lens' (ArtDecoPvsEntity a) (Maybe (NonEmptyList a))
_pvs_to_header_light = _pvs_to_header <<< prop (Proxy :: Proxy "light")