Mask PureScript CSS WIP

Mask.purs

module CSS.Mask
  (
  -- * Generic mask property.
    class Mask
  , mask

  -- * The mask-image
  , maskImage
  , maskImages
  , url

  -- * The mask-origin
  , maskOrigin
  , maskOrigins

  -- * The mask-position
  , maskPosition
  , maskPositions

  -- * The mask-type
  , MaskType(..)
  , maskType
  )
  where

import Prelude

import Data.Generic (class Generic)
import Data.Tuple (Tuple(..))

import CSS.Size (Size)


class Val a <= Mask a where
  mask :: a -> CSS

instance maskArray :: (Mask a) => Mask (Array a) where
  mask = key $ fromString "mask"

instance maskTuple :: (Mask a, Mask b) => Mask (Tuple a b) where
  mask = key $ fromString "mask"

instance maskImage' :: Mask MaskImage where
  mask = key $ fromString "mask"

instance maskImages' :: Mask (Array MaskImage) where
  maks = key $ fromString "mask"

instance maskPosition' :: Mask MaskPosition where
  mask = key $ fromString "mask"

instance maskType' :: Maske MaskType where
  make = key $ fromString "mask"

-------------------------------------------------------------------------------

-- Honestly GeometryBox needs to be a file
data MaskClip
  = MaskClipContentBox
  | MaskClipPaddingBox
  | MaskClipBorderBox
  | MaskClipMarginBox
  | MaskClipFillBox
  | MaskClipStrokeBox
  | MaskClipViewBox
  | MaskClipInherit
  | MaskClipInitial
  | MaskClipUnset

derive instance eqMaskClip :: Eq MaskClip
derive instance ordMaskClip :: Ord MaskClip
derive instance genericMaskClip :: Generic MaskClip

instance showMaskClip :: Show MaskClip where
  show = gShow

instance valMaskClip :: Val (MaskClip) where
  value = fromString <<< case _ of
    MaskClipContentBox -> "content-box"
    MaskClipPaddingBox -> "padding-box"
    MaskClipBorderBox -> "border-box"
    MaskClipMarginBox -> "margin-box"
    MaskClipFillBox -> "fill-box"
    MaskClipStrokeBox -> "stroke-box"
    MaskClipViewBox -> "view-box"
    MaskClipInherit -> "inherit"
    MaskClipInitial -> "initial"
    MaskClipUnset -> "unset"

instance inheritMaskClip :: Inherit MaskClip where
  inherit = MaskClipInherit

maskClip :: MaskClip -> CSS
maskClip = key $ fromString "mask-clip"

maskClips :: Array MaskClip -> CSS
maskClips = key $ fromString "mask-clip"

-------------------------------------------------------------------------------

newtype MaskImage = MaskImage Value

derive instance eqMaskImage :: Eq MaskImage
derive instance ordMaskImage :: Ord MaskImage
derive instance genericMaskImage :: Generic MaskImage

instance isStringMaskImage :: IsString MaskImage where
  fromString = MaskImage <<< fromString

instance valMaskImage :: Val MaskImage where
  value (MaskImage v) = v

instance otherMaskImage :: Other MaskImage where
  other = MaskImage

instance inheritMaskImage :: Inherit MaskImage where
  inherit = fromString "inherit"

instance noneMaskImage :: None MaskImage where
  none = fromString "none"

url :: String -> MaskImage
url u = MaskImage $ value  $ "url(\"" <> u <> "\")"

maskImage :: MaskImage -> CSS
maskImage = key $ fromString "mask-image"

maskImages :: Array MaskImage -> CSS
maskImages = key $ fromString "mask-image"

-------------------------------------------------------------------------------

data MaskOrigin
  = MaskOriginContentBox
  | MaskOriginPaddingBox
  | MaskOriginBorderBox
  | MaskOriginMarginBox
  | MaskOriginFillBox
  | MaskOriginStrokeBox
  | MaskOriginViewBox
  | MaskOriginInherit
  | MaskOriginInitial
  | MaskOriginUnset

derive instance eqMaskOrigin :: Eq MaskOrigin
derive instance ordMaskOrigin :: Ord MaskOrigin
derive instance genericMaskOrigin :: Generic MaskOrigin

instance showMaskOrigin :: Show MaskOrigin where
  show = gShow

instance valMaskOrigin :: Val (MaskOrigin) where
  value = fromString <<< case _ of
    MaskOriginContentBox -> "content-box"
    MaskOriginPaddingBox -> "padding-box"
    MaskOriginBorderBox -> "border-box"
    MaskOriginMarginBox -> "margin-box"
    MaskOriginFillBox -> "fill-box"
    MaskOriginStrokeBox -> "stroke-box"
    MaskOriginViewBox -> "view-box"
    MaskOriginInherit -> "inherit"
    MaskOriginInitial -> "initial"
    MaskOriginUnset -> "unset"

instance inheritMaskOrigin :: Inherit MaskOrigin where
  inherit = MaskOriginInherit

maskOrigin :: MaskOrigin -> CSS
maskOrigin = key $ fromString "mask-origin"

maskOrigins :: Array MaskOrigin -> CSS
maskOrigins = key $ fromString "mask-origin"

-------------------------------------------------------------------------------

newtype MaskPosition = MaskPosition Value

derive instance eqMaskPosition :: Eq MaskPosition
derive instance ordMaskPosition :: Ord MaskPosition
derive instance genericMaskPosition :: Generic MaskPosition

instance isStringMaskPosition :: IsString MaskPosition where
  fromString = MaskPosition <<< fromString

instance valMaskPosition :: Val MaskPosition where
  value (MaskPosition v) = v

instance otherMaskPosition :: Other MaskPosition where
  other = MaskPosition

instance inheritMaskPosition :: Inherit MaskPosition where
  inherit = fromString "inherit"

positioned :: forall a. Size a -> Size a -> MaskPosition
positioned a b = MaskPosition $ value $ Tuple a b

maskPosition :: MaskPosition -> CSS
maskPosition = key $ fromString "mask-position"

maskPositions :: Array MaskPosition -> CSS
maskPositions = key $ fromString "mask-position"

-------------------------------------------------------------------------------

data MaskType
  = MaskTypeLuminance
  | MaskTypeAlpha

derive instance eqMaskType :: Eq MaskType
derive instance ordMaskType :: Ord MaskType
derive instance genericMaskType :: Generic MaskType

instance showMaskType :: Show MaskType where
  show = gShow

instance valMaskType :: MaskType -> String
  value = fromString <<< case _ of
    MaskTypeLuminance -> "luminance"
    MaskTypeAlpha -> "alpha"

instance inheritMaskType :: Inherit MaskType where
  inherit = fromString "inherit"

maskType :: MaskType -> CSS
maskType = key $ fromString "mask-type"