StyleMock.hs

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE RequiredTypeArguments #-}

module Miso.Css.Test.StyleMock
  ( module Miso.Css.Test.StyleMock
  , module X
  ) where

import Data.ByteString.Lazy qualified as L
import Data.ByteString.Char8 qualified as C8
import Miso.Css.Style.PostAppend as Post
import Miso.Css.Test.Prelude as X

domLbs :: forall m a en es r ei atrs kids cls ecs children.
  ( UnwrapBranches (MapMaybeFilterOutFullyMatchedHead '[] ecs) ~ '[]
  , DuplicatedIds kids ~ '[]
  ) =>
  E m a en es r ei atrs kids cls ecs children ->
  L.ByteString
domLbs = toHtml . toView

doNotTcNoBr :: forall m a en es r ei atrs kids cls ecs children.
  forall exDids -> (DuplicatedIds kids ~ exDids) =>
  forall exEcs -> (UnwrapBranches (MapMaybeFilterOutFullyMatchedHead '[] ecs) ~ exEcs) =>
  E m a en es r ei atrs kids cls ecs children ->
  TestTree
doNotTcNoBr _ _ _ =
  testCase "see type message from the checker" do
    () @?= ()

doNotTc :: forall m a en es r ei atrs kids cls ecs children.
  forall exDids -> (DuplicatedIds kids ~ exDids) =>
  forall exEcs -> (MapMaybeFilterOutFullyMatchedHead '[] ecs ~ exEcs) =>
  E m a en es r ei atrs kids cls ecs children ->
  TestTree
doNotTc _ _ _ =
  testCase "see type message from the checker" do
    () @?= ()

go :: forall m a en es r ei atrs kids cls ecs children.
  ( UnwrapBranches (MapMaybeFilterOutFullyMatchedHead '[] ecs) ~ '[]
  , DuplicatedIds kids ~ '[]
  ) =>
  L.ByteString -> E m a en es r ei atrs kids cls ecs children -> TestTree
go ex el =
  testCase (C8.unpack $ C8.toStrict ex) do
    domLbs el @?= ex

infixl 1 `go`

a :: OrClass '[] "a"
a = TopOrClass pa
b :: OrClass '[] "b"
b = TopOrClass pb
c :: OrClass '[] "c"
c = TopOrClass pc
d :: OrClass '[] "d"
d = TopOrClass pd
pul :: Proxy "ul"
pul = Proxy @"ul"
{- HLINT ignore "Use camelCase" -}
ul_a :: OrClass '[ '[ '(NowOrLater, '[T "ul"], '[], '[])]] "a"
ul_a = AddAncestorBranch (AddSubSegConstraint (Proxy @T) pul $ CssOrphan nol) a
-- #x .a
id_a :: OrClass '[ '[ '(NowOrLater, '[I "b"], '[], '[])]] "a"
id_a = AddAncestorBranch (AddSubSegConstraint (Proxy @I) pb $ CssOrphan nol) a
pa :: Proxy "a"
pa = Proxy @"a"
pb :: Proxy "b"
pb = Proxy @"b"
pc :: Proxy "c"
pc = Proxy @"c"
pd :: Proxy "d"
pd = Proxy @"d"

type Ai = ElementId "a"
type Bi = ElementId "b"
type Ci = ElementId "c"
type Di = ElementId "d"

nol_c :: OrClass '[ '[ '(NowOrLater, '[], '[], '[])]] "c"
nol_c = AddAncestorBranch (CssOrphan nol) c
jn_c :: OrClass '[ '[ '(JustNow, '[], '[], '[])]] "c"
jn_c =  AddAncestorBranch (CssOrphan jn) c

ac :: OrClass '[ '[ '(NowOrLater, '[C "a"], '[], '[])]] "c"
ac = AddAncestorBranch (AddSubSegConstraint (Proxy @C) pa $ CssOrphan nol) c

-- .a _ .b
ab :: OrClass '[ [ '(AutoClean, '[], '[], '[])
                 , '(NowOrLater, '[C "a"], '[], '[])
                 ] ] "b"
ab =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor acn) ) b

-- .a _ .b _ .c
abc :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(NowOrLater, '[C "b"], '[], '[])
     , '(NowOrLater, '[C "a"], '[], '[])
     ] ] "c"
abc =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor nol
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c
-- .a.b _ .c
ab_c :: OrClass '[['(AutoClean, '[], '[], '[]), '(NowOrLater, [C "b", C "a"], '[], '[])]] "c"
ab_c =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c
-- .b.a _ .c
ba_c :: OrClass '[ '[ '(NowOrLater, [C "a", C "b"], '[], '[])]] "c"
ba_c =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pb
  >>> AddSubSegConstraint (Proxy @C) pa) )
  c
-- #c.a _ .b
idC_and_a_b :: OrClass '[ '[ '(NowOrLater, [I "c", C "a"], '[], '[])]] "b"
idC_and_a_b =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> AddSubSegConstraint (Proxy @I) pc) )
  b
ul_and_a_b :: OrClass '[ '[ '(NowOrLater, [T "ul", C "a"], '[], '[])]] "b"
ul_and_a_b =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> AddSubSegConstraint (Proxy @T) pul) )
  b
-- id_a = AddAncestorBranch (AddSubSegConstraint (Proxy @I) pb $ CssOrphan nol) a
a_id_a :: OrClass '[ '[ '(AutoClean, '[I "a"], '[], '[])]] "a"
a_id_a =
  AddAncestorBranch (CssOrphan acn & AddSubSegConstraint (Proxy @I) pa) a

-- .a.b
a_next_to_b :: OrClass '[ '[ '(AutoClean, '[C "a"], '[], '[])]] "b"
a_next_to_b =
  AddAncestorBranch (CssOrphan acn & AddSubSegConstraint (Proxy @C) pa) b

-- .c > .a.b
c_dir_a_with_b :: OrClass
  '[ [ '(AutoClean, '[C "a"], '[], '[])
     , '(JustNow, '[C "c"], '[], '[])
     ] ] "b"
c_dir_a_with_b =
  AddAncestorBranch
  ( CssOrphan jn
  & (   AddSubSegConstraint (Proxy @C) pc
    >>> NextAncestor acn
    >>> AddSubSegConstraint (Proxy @C) pa))
  b

-- .b.a
b_next_to_a :: OrClass '[ '[ '(AutoClean, '[C "b"], '[], '[])]] "a"
b_next_to_a =
  AddAncestorBranch
  (AddSubSegConstraint (Proxy @C) pb $ CssOrphan acn) a
-- .a[a]
a_wants_a_attr :: OrClass '[ '[ '(AutoClean, '[A "a"], '[], '[])]] "a"
a_wants_a_attr = AddAncestorBranch (AddSubSegConstraint (Proxy @A) pa $ CssOrphan acn) a
-- [a] > .a
a_wants_a_attr_in_parent :: OrClass '[ '[ '(JustNow, '[A "a"], '[], '[])]] "a"
a_wants_a_attr_in_parent = AddAncestorBranch (AddSubSegConstraint (Proxy @A) pa $ CssOrphan jn) a

pdiv :: Proxy "div"
pdiv = Proxy @"div"
div_child :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[T "div"], '[], '[])
     ] ]   "div_child"
div_child = -- div > .div_child
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @T) pdiv
  >>> NextAncestor acn) )
  (TopOrClass (Proxy @"div_child"))
div_ul_child :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[T "ul"], '[], '[])
     , '(JustNow, '[T "div"], '[], '[])
     ]
   ] "div_ul_child"
div_ul_child =
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @T) pdiv
  >>> NextAncestor jn
  >>> AddSubSegConstraint (Proxy @T) pul
  >>> NextAncestor acn) )
  (TopOrClass (Proxy @"div_ul_child"))
-- .a > .b > .c
a_dir_b_dir_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "b"], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     ]
   ] "c"
a_dir_b_dir_c =
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor jn
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c
-- .a > .b _ .c
a_dir_b_sp_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(NowOrLater, '[C "b"], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     ] ] "c"
a_dir_b_sp_c =
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor nol
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c
-- .a _ .b > .c
a_sp_b_dir_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "b"], '[], '[])
     , '(NowOrLater, '[C "a"], '[], '[])
     ] ] "c"
a_sp_b_dir_c =
  AddAncestorBranch
  (   CssOrphan nol
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor jn
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c

-- .a > .b > .c > .d
a_dir_b_dir_c_dir_d :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "c"], '[], '[])
     , '(JustNow, '[C "b"], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     ]
   ] "d"
a_dir_b_dir_c_dir_d =
  AddAncestorBranch
  (   CssOrphan jn -- .a
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor jn -- .b
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor jn -- .c
  >>> AddSubSegConstraint (Proxy @C) pc
  >>> NextAncestor acn) )
  d
-- * > * > .c
star_dir_star_dir_c :: OrClass '[['(JustNow, '[], '[], '[]), '(JustNow, '[], '[], '[])]] "c"
star_dir_star_dir_c =
  AddAncestorBranch (CssOrphan jn & NextAncestor jn)
  c
-- .a > .b
a_dir_b :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     ] ] "b"
a_dir_b =
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor acn) )
  b

-- .a > .b _ .c
a_dir_b_spc_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(NowOrLater, '[C "b"], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     ] ] "c"
a_dir_b_spc_c =
  AddAncestorBranch
  (   CssOrphan jn
  & ( AddSubSegConstraint (Proxy @C) pa
  >>> NextAncestor nol
  >>> AddSubSegConstraint (Proxy @C) pb
  >>> NextAncestor acn) )
  c
-- .a + .b
a_dirSib_b :: OrClass
  '[ [ '(AutoClean,  '[], '[], '[])
     , '(NowOrLater, '[], '[], '[ '[ '(JustNow, '[C "a"])]])
     ] ] "b"
a_dirSib_b =
  AddAncestorBranch
    (   CssOrphan nol
    & ( AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor acn) )
    b
-- .a + .b + .c
a_dirSib_b_dirSib_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[], '[], '[ [ '(JustNow, '[C "b"])
                               , '(JustNow, '[C "a"]) ] ])
     ] ] "c"
a_dirSib_b_dirSib_c =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddSiblingBranch
        (   AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn)
        >>> AddSegToSibBranch (AddSib (Proxy @C) pb $ NilSib jn)
        $   NilSibBranch
        )
    >>> NextAncestor acn
      ) )
    c

-- .a ~ .b ~ .c
a_genSib_b_genSib_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[], '[], '[['(NowOrLater, '[C "b"]), '(NowOrLater, '[C "a"])]])
     ] ] "c"
a_genSib_b_genSib_c =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddSiblingBranch
        (   AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib nol)
        >>> AddSegToSibBranch (AddSib (Proxy @C) pb $ NilSib nol)
        $   NilSibBranch
        )
    >>> NextAncestor acn
      ) )
    c
-- _ .c > .a + .b
c_dir_a_dirSib_b :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "c"], '[], '[ '[ '(JustNow, '[C "a"])]]) ] ] "b"
c_dir_a_dirSib_b =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddSubSegConstraint (Proxy @C) pc
    >>> AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor acn) )
    b
-- _ | .c > .a + .b _ .d
c_dir_a_dirSib_b_spc_d :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(NowOrLater, '[C "b"], '[], '[])
     , '(JustNow, '[C "c"], '[], '[ '[ '(JustNow, '[C "a"])]])
     ] ] "d"
c_dir_a_dirSib_b_spc_d =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddSubSegConstraint (Proxy @C) pc
    >>> AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor nol
    >>> AddSubSegConstraint (Proxy @C) pb
    >>> NextAncestor acn) )
    d
-- .a.b > .c
a_with_b_dir_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, [C "b", C "a"], '[], '[])
     ] ] "c"
a_with_b_dir_c =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddSubSegConstraint (Proxy @C) pa
    >>> AddSubSegConstraint (Proxy @C) pb
    >>> NextAncestor acn) )
    c
-- .a.b + .c
a_with_b_dirSib_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[], '[], '[ '[ '(JustNow, [C "b", C "a"])]]) ] ] "c"
a_with_b_dirSib_c =
  AddAncestorBranch
    (   AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pb $ AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor acn
    $   CssOrphan jn ) -- or nol - does not matter
    c

pspan :: Proxy "span"
pspan = Proxy @"span"
pp :: Proxy "p"
pp = Proxy @"p"

-- _ | p ~ span > .a
p_genSib_span_dir_a =
  AddAncestorBranch
    (   CssOrphan jn    -- >
    & ( AddSiblingBranch
          (   AddSegToSibBranch (AddSib (Proxy @T) pp $ NilSib nol)
              NilSibBranch )
    >>> NextAncestor jn -- siblings
    >>> AddSubSegConstraint (Proxy @T) pspan
    >>> NextAncestor acn
      ) )
    a

-- _ | div + p ~ span > .a
div_dirSib_p_genSib_span_dir_a =
  AddAncestorBranch
    (   CssOrphan jn    -- >
    & ( AddSiblingBranch
          (   AddSegToSibBranch (AddSib (Proxy @T) pdiv $ NilSib jn)
          >>> AddSegToSibBranch (AddSib (Proxy @T) pp $ NilSib nol)
          $   NilSibBranch )
    >>> NextAncestor jn -- siblings
    >>> AddSubSegConstraint (Proxy @T) pspan
    >>> NextAncestor acn) )
    a

-- _ | div + p ~ span > .a + .b
div_dirSib_p_genSib_span_dir_a_dirSib_b :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[T "span"], '[], '[ '[ '(JustNow, '[C "a"])]])
     , '(JustNow, '[], '[], '[['(NowOrLater, '[T "p"]), '(JustNow, '[T "div"])]])
     ] ] "b"
div_dirSib_p_genSib_span_dir_a_dirSib_b =
  AddAncestorBranch
    (   CssOrphan jn    -- >
    & ( AddSiblingBranch
          (   AddSegToSibBranch (AddSib (Proxy @T) pdiv $ NilSib jn)
          >>> AddSegToSibBranch (AddSib (Proxy @T) pp $ NilSib nol)
          $   NilSibBranch )
    >>> NextAncestor jn -- siblings
    >>> AddSubSegConstraint (Proxy @T) pspan
    >>> AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor acn) )
    b

-- _ | div ~ p + span > .a + .b
div_genSib_p_dirSib_span_dir_a_dirSib_b :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[T "span"], '[], '[ '[ '(JustNow, '[C "a"])]])
     , '(JustNow, '[], '[], '[['(JustNow, '[T "p"]), '(NowOrLater, '[T "div"])]])
     ] ] "b"
div_genSib_p_dirSib_span_dir_a_dirSib_b =
  AddAncestorBranch
    (   CssOrphan jn    -- >
    & ( AddSiblingBranch
        (   NilSibBranch
        & ( AddSegToSibBranch (AddSib (Proxy @T) pdiv $ NilSib nol)
        >>> AddSegToSibBranch (AddSib (Proxy @T) pp $ NilSib jn) )
        )
    >>> NextAncestor jn -- siblings
    >>> AddSubSegConstraint (Proxy @T) pspan
    >>> AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor acn) )
    b

-- .a + .b > .c
a_dirSib_b_dir_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "b"], '[], '[])
     , '(JustNow, '[], '[], '[ '[ '(JustNow, '[C "a"]) ] ])
     ] ] "c"
a_dirSib_b_dir_c =
  AddAncestorBranch
    (   CssOrphan jn    -- >
    & ( AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib jn) NilSibBranch)
    >>> NextAncestor jn -- always jn for + or ~
    >>> AddSubSegConstraint (Proxy @C) pb
    >>> NextAncestor acn) )
    c

-- .a ~ .b
a_genSib_b :: OrClass
  '[ [ '(AutoClean,  '[], '[], '[])
     , '(JustNow, '[], '[], '[ '[ '(NowOrLater, '[C "a"]) ]])
     ] ] "b"
a_genSib_b =
  AddAncestorBranch
    (   CssOrphan jn -- nol is the same here
    & ( AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib nol) NilSibBranch)
    >>> NextAncestor acn) )
    b

-- .a ~ .b _ .c
a_genSib_b_spc_c :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(NowOrLater, '[C "b"], '[], '[])
     , '(NowOrLater, '[], '[], '[ '[ '(NowOrLater, '[C "a"])]])
     ] ] "c"
a_genSib_b_spc_c =
  AddAncestorBranch
    (   CssOrphan nol
    & ( AddSiblingBranch (AddSegToSibBranch (AddSib (Proxy @C) pa $ NilSib nol) NilSibBranch)
    >>> NextAncestor nol -- always nol for ~
    >>> AddSubSegConstraint (Proxy @C) pb
    >>> NextAncestor acn) )
    c

root_b :: OrClass '[ '[ '(NowOrLater, '[R], '[], '[])]] "b"
root_b =
  AddAncestorBranch
    (AddRoot $ CssOrphan nol)
    b
-- :root > body > .a > .b
root_dir_body_dir_a_dir_b :: OrClass
  '[ [ '(AutoClean, '[], '[], '[])
     , '(JustNow, '[C "a"], '[], '[])
     , '(JustNow, '[T BODY], '[], '[])
     , '(JustNow, '[R], '[], '[])
     ]
   ] "b"
root_dir_body_dir_a_dir_b =
  AddAncestorBranch
    (   CssOrphan jn
    & ( AddRoot
    >>> NextAncestor jn
    >>> AddSubSegConstraint (Proxy @T) (Proxy @BODY)
    >>> NextAncestor jn
    >>> AddSubSegConstraint (Proxy @C) pa
    >>> NextAncestor acn) )
    b