elm-pages 3.0.0-beta.13 → 3.0.0-beta.15

package/src/DataSource/Port.elm

@@ -1,90 +0,0 @@
-module DataSource.Port exposing (get)
-
-{-|
-
-@docs get
-
--}
-
-import DataSource
-import DataSource.Http
-import DataSource.Internal.Request
-import Json.Decode exposing (Decoder)
-import Json.Encode as Encode
-
-
-{-| In a vanilla Elm application, ports let you either send or receive JSON data between your Elm application and the JavaScript context in the user's browser at runtime.
-
-With `DataSource.Port`, you send and receive JSON to JavaScript running in NodeJS during build-time. This means that you can call shell scripts, or run NPM packages that are installed, or anything else you could do with NodeJS.
-
-A `DataSource.Port` will call an async JavaScript function with the given name. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
-
-Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or a build error if it isn't found).
-
-    import DataSource exposing (DataSource)
-    import DataSource.Port
-    import Json.Encode
-    import OptimizedDecoder as Decode
-
-    data : DataSource String
-    data =
-        DataSource.Port.get "environmentVariable"
-            (Json.Encode.string "EDITOR")
-            Decode.string
-
-    -- will resolve to "VIM" if you run `EDITOR=vim elm-pages dev`
-
-```javascript
-const kleur = require("kleur");
-
-
-module.exports =
-  /**
-   * @param { unknown } fromElm
-   * @returns { Promise<unknown> }
-   */
-  {
-    environmentVariable: async function (name) {
-      const result = process.env[name];
-      if (result) {
-        return result;
-      } else {
-        throw `No environment variable called ${kleur
-          .yellow()
-          .underline(name)}\n\nAvailable:\n\n${Object.keys(process.env).join(
-          "\n"
-        )}`;
-      }
-    },
-  }
-```
-
-
-## Error Handling
-
-`port-data-source.js`
-
-Any time you throw an exception from a DataSource.Port definition, it will result in a build error in your `elm-pages build` or dev server. In the example above, if the environment variable
-is not found it will result in a build failure. Notice that the NPM package `kleur` is being used in this example to add color to the output for that build error. You can use any tool you
-prefer to add ANSI color codes within the error string in an exception and it will show up with color output in the build output and dev server.
-
-
-## Performance
-
-As with any JavaScript or NodeJS code, avoid doing blocking IO operations. For example, avoid using `fs.readFileSync`, because blocking IO can slow down your elm-pages builds and dev server.
-
--}
-get : String -> Encode.Value -> Decoder b -> DataSource.DataSource b
-get portName input decoder =
-    DataSource.Internal.Request.request
-        { name = "port"
-        , body =
-            Encode.object
-                [ ( "input", input )
-                , ( "portName", Encode.string portName )
-                ]
-                |> DataSource.Http.jsonBody
-        , expect =
-            decoder
-                |> DataSource.Http.expectJson
-        }

package/src/MultiDict.elm

@@ -1,49 +0,0 @@
-module MultiDict exposing (MultiDict, empty, get, insert, keys, remove, set)
-
-import Dict exposing (Dict)
-import List.Extra
-import List.Nonempty as NonEmpty
-
-
-type alias NonEmpty a =
-    NonEmpty.Nonempty a
-
-
-type MultiDict k v
-    = MultiDict (Dict k (NonEmpty v))
-
-
-empty : MultiDict k v
-empty =
-    MultiDict Dict.empty
-
-
-insert : comparable -> v -> MultiDict comparable v -> MultiDict comparable v
-insert key value (MultiDict dict) =
-    MultiDict
-        (Dict.update key (Maybe.map (NonEmpty.cons value) >> Maybe.withDefault (NonEmpty.fromElement value) >> Just) dict)
-
-
-get : comparable -> MultiDict comparable v -> List v
-get key (MultiDict dict) =
-    Dict.get key dict
-        |> Maybe.map NonEmpty.toList
-        |> Maybe.withDefault []
-
-
-keys : MultiDict k v -> List k
-keys (MultiDict dict) =
-    Dict.toList dict
-        |> List.concatMap (\( k, vs ) -> List.repeat (NonEmpty.length vs) k)
-
-
-remove : comparable -> v -> MultiDict comparable v -> MultiDict comparable v
-remove key value (MultiDict dict) =
-    MultiDict
-        (Dict.update key (Maybe.andThen (NonEmpty.toList >> List.Extra.remove value >> NonEmpty.fromList)) dict)
-
-
-set : comparable -> List v -> MultiDict comparable v -> MultiDict comparable v
-set key values (MultiDict dict) =
-    MultiDict
-        (Dict.update key (\_ -> NonEmpty.fromList values) dict)

package/src/PairingHeap.elm

@@ -1,137 +0,0 @@
-module PairingHeap exposing
-    ( PairingHeap, empty
-    , insert, merge, findMin, deleteMin
-    , fromList, toSortedList
-    )
-
-{-| This is a simple pairing heap implementation written in Elm usable as a priority queue. This code is
-based heavily on the pseudocode available at [the Wikipedia page](https://en.wikipedia.org/wiki/Pairing_heap).
-
-
-# Type and Constructor
-
-@docs PairingHeap, empty
-
-
-# Operations
-
-@docs insert, merge, findMin, deleteMin
-
-
-# Convenience functions
-
-@docs fromList, toSortedList
-
--}
-
-
-{-| A `PairingHeap` has comparable keys and values of an arbitrary type.
--}
-type PairingHeap comparable a
-    = Empty
-    | Heap comparable a (List (PairingHeap comparable a))
-
-
-{-| Create an empty PairingHeap.
--}
-empty : PairingHeap comparable a
-empty =
-    Empty
-
-
-{-| Find the minimum value in a heap returning Nothing if the heap is empty.
-Complexity: O(1)
-
-    findMin (fromList [ ( 10, () ), ( 3, () ), ( 8, () ) ]) == Just 3
-
--}
-findMin : PairingHeap comparable a -> Maybe ( comparable, a )
-findMin x =
-    case x of
-        Empty ->
-            Nothing
-
-        Heap k v _ ->
-            Just ( k, v )
-
-
-{-| Merges two `PairingHeap`s together into one new heap containing all of the key-value pairs from both inputs.
-Complexity: O(1)
--}
-merge : PairingHeap comparable a -> PairingHeap comparable a -> PairingHeap comparable a
-merge heap1 heap2 =
-    case ( heap1, heap2 ) of
-        ( Empty, _ ) ->
-            heap2
-
-        ( _, Empty ) ->
-            heap1
-
-        ( Heap k1 v1 hs1, Heap k2 v2 hs2 ) ->
-            if k1 < k2 then
-                Heap k1 v1 (heap2 :: hs1)
-
-            else
-                Heap k2 v2 (heap1 :: hs2)
-
-
-{-| Inserts a new element into a `PairingHeap`.
-Complexity: O(1)
--}
-insert : comparable -> a -> PairingHeap comparable a -> PairingHeap comparable a
-insert k v heap =
-    merge (Heap k v []) heap
-
-
-{-| Removes the minimum element from a `PairingHeap` returning a new heap without that element.
-This will return an empty heap if given an empty heap as input.
-Complexity: O(log n)
--}
-deleteMin : PairingHeap comparable a -> PairingHeap comparable a
-deleteMin heap =
-    case heap of
-        Empty ->
-            Empty
-
-        Heap k v heaps ->
-            mergePairs heaps
-
-
-{-| This is an internal function used by deleteMin.
--}
-mergePairs : List (PairingHeap comparable a) -> PairingHeap comparable a
-mergePairs heaps =
-    case heaps of
-        [] ->
-            Empty
-
-        x :: [] ->
-            x
-
-        x :: (y :: xs) ->
-            merge (merge x y) (mergePairs xs)
-
-
-
--- Extra convenience functions
-
-
-{-| This function turns a list of key-value pairs into a `PairingHeap`.
-Complexity: O(n)
--}
-fromList : List ( comparable, a ) -> PairingHeap comparable a
-fromList =
-    List.foldl (\( k, v ) -> insert k v) empty
-
-
-{-| This function turns a `PairingHeap` into a sorted list of key-value pairs.
-Complexity: O(n log n)
--}
-toSortedList : PairingHeap comparable a -> List ( comparable, a )
-toSortedList heap =
-    case heap of
-        Empty ->
-            []
-
-        Heap k v _ ->
-            ( k, v ) :: toSortedList (deleteMin heap)

package/src/Parser/Extra/String.elm

@@ -1,33 +0,0 @@
-module Parser.Extra.String exposing (string)
-
-import Parser exposing (..)
-
-
-string : Parser String
-string =
-    succeed identity
-        |. token "\""
-        |= loop [] stringHelp
-
-
-stringHelp : List String -> Parser (Step (List String) String)
-stringHelp revChunks =
-    oneOf
-        [ succeed (\chunk -> Loop (chunk :: revChunks))
-            |. token "\\"
-            |= oneOf
-                [ map (\_ -> "\n") (token "n")
-                , map (\_ -> "\t") (token "t")
-                , map (\_ -> "\u{000D}") (token "r")
-                ]
-        , token "\""
-            |> map (\_ -> Done (String.join "" (List.reverse revChunks)))
-        , chompWhile isUninteresting
-            |> getChompedString
-            |> map (\chunk -> Loop (chunk :: revChunks))
-        ]
-
-
-isUninteresting : Char -> Bool
-isUninteresting char =
-    char /= '\\' && char /= '"'

package/src/Parser/Extra.elm

@@ -1,69 +0,0 @@
-module Parser.Extra exposing (deadEndsToString)
-
-{-| [No implementation for deadEndsToString · Issue #9 · elm/parser](https://github.com/elm/parser/issues/9)
--}
-
-import Parser exposing (DeadEnd, Problem(..))
-
-
-deadEndsToString : List DeadEnd -> String
-deadEndsToString deadEnds =
-    String.join "\n" (List.map deadEndToString deadEnds)
-
-
-deadEndToString : DeadEnd -> String
-deadEndToString deadEnd =
-    problemToString deadEnd.problem
-        ++ " at "
-        ++ deadEndToRowColString deadEnd
-
-
-problemToString : Problem -> String
-problemToString prob =
-    case prob of
-        Expecting s ->
-            "Expecting " ++ s
-
-        ExpectingInt ->
-            "Expecting Int"
-
-        ExpectingHex ->
-            "Expecting Hex"
-
-        ExpectingOctal ->
-            "Expecting Octal"
-
-        ExpectingBinary ->
-            "Expecting Binary"
-
-        ExpectingFloat ->
-            "Expecting Float"
-
-        ExpectingNumber ->
-            "Expecting Number"
-
-        ExpectingVariable ->
-            "Expecting Variable"
-
-        ExpectingSymbol s ->
-            "Expecting Symbol " ++ s
-
-        ExpectingKeyword s ->
-            "Expecting Keyword " ++ s
-
-        ExpectingEnd ->
-            "Expecting End"
-
-        UnexpectedChar ->
-            "Unexpected Char"
-
-        Problem s ->
-            "Problem: " ++ s
-
-        BadRepeat ->
-            "Bad Repeat"
-
-
-deadEndToRowColString : DeadEnd -> String
-deadEndToRowColString deadEnd =
-    "row " ++ String.fromInt deadEnd.row ++ ", " ++ "col " ++ String.fromInt deadEnd.col