This is an alternative site for discovering Elm packages. You may be looking for the official Elm package site instead.
README ProgramEx

ProgramEx.States

This module handles the States structure that controls how callbacks will be called

Example usage via in a filter callback:

filters : Msg -> Model -> ( Msg, States Model Msg )
filters msg model =
    let
        log =
            debug_log (model.programFlags.debug_log |> Maybe.withDefault False) "filters" ( msg, model )
    in
        case msg of
            Helpers helpersMsg ->
                ( msg
                , States.enableAll |> States.delegate (helpers_delegate Helpers helpersMsg)
                )

            Mdl mdlMsg ->
                ( msg
                , States.enableAll
                    |> States.delegate
                        { key = "Mdl"
                        , update = Just (\_ o -> Material.update mdlMsg o)
                        , subscriptions = Just (\o -> Material.subscriptions Mdl o)
                        }
                )

            MesgList_Scroll scrolled ->
                case model.loc of
                    RoomLocation rid _ ->
                        let
                            doLoad : Bool
                            doLoad =
                                (model.firstMessageReached == False)
                                    && (scrolled.pos < 16)
                                    && (model.isLoadingOlder == False)
                                    && ((Dict.size model.active_room_msgs) >= 10)
                        in
                            if doLoad then
                                ( MesgList_LoadOlder rid, States.enableAll )
                            else
                                ( msg, States.disableAll )

                    _ ->
                        ( msg, States.disableAll )

            _ ->
                ( msg, States.enableAll )
type States userModel userMsg = S { doUpdate : Bool , doSubscriptions : Bool , doView : Bool , callbackDelegates : Maybe (Delegates userModel userMsg) }

Holds the State information

type Callbacks = Update | Subscriptions | View

Various supported states that can be allowed or denied

type alias Delegates userModel userMsg = { key : String , update : Maybe ( userMsg -> userModel -> ( userModel, Cmd userMsg ) ) , subscriptions : Maybe ( userModel -> Sub userMsg ) }

Delegate record, fill this in to specify delegates for a module

defaultOn : States userModel userMsg

Gets the default state set, everything is enabled

defaultOff : States userModel userMsg

Gets the default state set, everything is disabled

enableAll : States userModel userMsg

Runs all callbacks as expected, same as defaultOn

disableAll : States userModel userMsg

Runs no callbacks at all, same as defaultOff

enableOnly : List Callbacks -> States userModel userMsg

Returns a State that will only allow these callbacks to run

disableOnly : List Callbacks -> States userModel userMsg

Returns a State that will only allow all callbacks except the ones specified

enable : Callbacks -> States userModel userMsg -> States userModel userMsg

Returns a new state from an old enabling a specific callback

disable : Callbacks -> States userModel userMsg -> States userModel userMsg

Returns a new state from an old disabling a specific callback

delegate : Delegates userModel userMsg -> States userModel userMsg -> States userModel userMsg

Changes the callback functions for these callbacks to the specified ones, useful for TEA modules delegation

Example use:

filters : Msg -> Model -> ( Msg, States )
filters msg model =
  case msg of
    Material
doUpdate : States userModel userMsg -> Bool

Gets from the state if the update callback should be run

doSubscriptions : States userModel userMsg -> Bool

Gets from the state if the subscriptions callback should be run

doView : States userModel userMsg -> Bool

Gets from the state if the view callback should be run

getDelegates : States userModel userMsg -> Maybe (Delegates userModel userMsg)

Gets the delegates for this state

module ProgramEx.States exposing
  ( States
  , Callbacks(..)
  , Delegates
  , defaultOn, defaultOff
  , enableAll, disableAll
  , enableOnly, disableOnly
  , enable, disable
  , delegate
  , doUpdate, doSubscriptions, doView, getDelegates
  )

{-|
This module handles the States structure that controls how callbacks will be called

Example usage via in a filter callback:

    filters : Msg -> Model -> ( Msg, States Model Msg )
    filters msg model =
        let
            log =
                debug_log (model.programFlags.debug_log |> Maybe.withDefault False) "filters" ( msg, model )
        in
            case msg of
                Helpers helpersMsg ->
                    ( msg
                    , States.enableAll |> States.delegate (helpers_delegate Helpers helpersMsg)
                    )

                Mdl mdlMsg ->
                    ( msg
                    , States.enableAll
                        |> States.delegate
                            { key = "Mdl"
                            , update = Just (\_ o -> Material.update mdlMsg o)
                            , subscriptions = Just (\o -> Material.subscriptions Mdl o)
                            }
                    )

                MesgList_Scroll scrolled ->
                    case model.loc of
                        RoomLocation rid _ ->
                            let
                                doLoad : Bool
                                doLoad =
                                    (model.firstMessageReached == False)
                                        && (scrolled.pos < 16)
                                        && (model.isLoadingOlder == False)
                                        && ((Dict.size model.active_room_msgs) >= 10)
                            in
                                if doLoad then
                                    ( MesgList_LoadOlder rid, States.enableAll )
                                else
                                    ( msg, States.disableAll )

                        _ ->
                            ( msg, States.disableAll )

                _ ->
                    ( msg, States.enableAll )


@docs States, Callbacks, Delegates
@docs defaultOn, defaultOff
@docs enableAll, disableAll
@docs enableOnly, disableOnly
@docs enable, disable
@docs delegate
@docs doUpdate, doSubscriptions, doView, getDelegates
-}



{-| Delegate record, fill this in to specify delegates for a module
-}
type alias Delegates userModel userMsg =
  { key : String
  , update : Maybe ( userMsg -> userModel -> ( userModel, Cmd userMsg ) )
  , subscriptions : Maybe ( userModel -> Sub userMsg )
  }


{-| Holds the State information
-}
type States userModel userMsg =
  S { doUpdate : Bool
    , doSubscriptions : Bool
    , doView : Bool
    , callbackDelegates : Maybe (Delegates userModel userMsg)
    }


{-| Various supported states that can be allowed or denied
-}
type Callbacks
  = Update
  | Subscriptions
  | View


{-| Gets the default state set, everything is enabled
-}
defaultOn : States userModel userMsg
defaultOn =
  S { doUpdate=True
    , doSubscriptions=True
    , doView=True
    , callbackDelegates=Nothing
    }



{-| Gets the default state set, everything is disabled
-}
defaultOff : States userModel userMsg
defaultOff =
  S { doUpdate=False
    , doSubscriptions=False
    , doView=False
    , callbackDelegates=Nothing
    }


{-| Gets from the state if the update callback should be run
-}
doUpdate : States userModel userMsg -> Bool
doUpdate (S states) = states.doUpdate


{-| Gets from the state if the subscriptions callback should be run
-}
doSubscriptions : States userModel userMsg -> Bool
doSubscriptions (S states) = states.doSubscriptions


{-| Gets from the state if the view callback should be run
-}
doView : States userModel userMsg -> Bool
doView (S states) = states.doView


{-| Gets the delegates for this state
-}
getDelegates : States userModel userMsg -> Maybe (Delegates userModel userMsg)
getDelegates (S states) =
  states.callbackDelegates


-- User userfuls


{-| Runs all callbacks as expected, same as `defaultOn`
-}
enableAll : States userModel userMsg
enableAll =
  defaultOn


{-| Runs no callbacks at all, same as `defaultOff`
-}
disableAll : States userModel userMsg
disableAll =
  defaultOff


{-| Returns a State that will only allow these callbacks to run
-}
enableOnly : List Callbacks -> States userModel userMsg
enableOnly only =
  List.foldl enable disableAll only


{-| Returns a State that will only allow all callbacks except the ones specified
-}
disableOnly : List Callbacks -> States userModel userMsg
disableOnly only =
  List.foldl disable enableAll only


{-| Returns a new state from an old enabling a specific callback
-}
enable : Callbacks -> States userModel userMsg -> States userModel userMsg
enable state (S states) =
  case state of
    Update -> S { states | doUpdate = True }
    Subscriptions -> S { states | doSubscriptions = True }
    View -> S { states | doView = True }



{-| Returns a new state from an old disabling a specific callback
-}
disable : Callbacks -> States userModel userMsg -> States userModel userMsg
disable state (S states) =
  case state of
  Update -> S { states | doUpdate = True }
  Subscriptions -> S { states | doSubscriptions = True }
  View -> S { states | doView = True }


{-| Changes the callback functions for these callbacks to the specified ones, useful for TEA modules delegation

Example use:

    filters : Msg -> Model -> ( Msg, States )
    filters msg model =
      case msg of
        Material
-}
delegate : Delegates userModel userMsg -> States userModel userMsg -> States userModel userMsg
delegate  delegates (S states) =
  S { states | callbackDelegates = Just delegates
    }