-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT
{-# LANGUAGE TypeFamilies #-}

{- | npm policy facts collected beside the existing packed writer.
The walk still owns shapes, depth checks and first-member handling.
Only the three install hooks retain script names, and no command survives in typed facts.
A dependency spec is classified where it is read, and only an external one is kept.
-}
module Ecluse.Core.Registry.Npm.VersionWriter (
    -- * Packing
    VersionWriter,
    newVersionWriter,
    packedWriter,
    sealVersion,
    discardVersion,

    -- * Typed facts
    VersionValue,
    versionFacts,
) where

import Control.Monad.ST (ST)
import Data.Aeson (FromJSON (parseJSON), Value (..))
import Data.Aeson.Types (parseMaybe)
import Data.Map.Strict qualified as Map
import Data.Primitive.MutVar (MutVar, newMutVar, readMutVar, writeMutVar)
import Data.Set qualified as Set

import Ecluse.Core.Package (Availability (Available))
import Ecluse.Core.Registry.Json.Intern (Entry, entryString, entryText, nameText)
import Ecluse.Core.Registry.Json.Packed (Packed)
import Ecluse.Core.Registry.Json.Shape (Build (..), MemberKey (..), memberText)
import Ecluse.Core.Registry.Json.Walk (Steps)
import Ecluse.Core.Registry.Json.Writer (Frame, Writer, discard, newWriter, sealValue)
import Ecluse.Core.Registry.Npm.DependencySource (ExternalDependency (ExternalDependency), ExternalSource, InstallableField (..), earlierDependency, externalSource)
import Ecluse.Core.Registry.Npm.Project (installHooks)
import Ecluse.Core.Registry.Npm.Wire (Dist, License, Person, VersionManifest (..), availability, distFields, distFromFields, licenseFromFields, personFromFields)

-- | One read's packed storage and the role of the next value.
data VersionWriter st = VersionWriter
    { forall st. VersionWriter st -> Writer st
packedWriter :: Writer st
    -- ^ The existing diagnostic decoder reads this writer's sealed values.
    , forall st. VersionWriter st -> MutVar st Role
nextRole :: MutVar st Role
    }

-- | A completed value. Invalid facts require the existing whole-release diagnostic decoder.
data VersionValue
    = ScalarValue Value
    | IntegerValue Int
    | DistValue (Maybe Dist)
    | LicenseValue (Maybe License)
    | PersonValue Bool
    | StringCommand
    | ScriptValue (Maybe (Map Text Text))
    | ReleaseValue (Maybe VersionManifest)
    | ExternalSpec ExternalSource
    | -- A dependency spec, or a whole dependency map, that fetches nothing from outside the registry.
      NoExternalSpec
    | ExternalMap ExternalDependency
    | Unobserved

data Role = Release | ScalarField | DistObject | LicenseObject | PersonObject | Scripts | Command | DependencyMap InstallableField | DependencySpec | Ignore

data VersionFrame
    = VersionFrame Frame ObservedFields (Set Text)
    | IgnoredFrame Frame VersionValue

data ObservedFields
    = ReleaseFields Manifest
    | DistFields (Maybe Text) (Maybe (Maybe Text)) (Maybe (Maybe Text)) (Maybe Int)
    | LicenseFields (Maybe (Maybe Text)) (Maybe (Maybe Text))
    | PersonFields (Maybe (Maybe Text)) (Maybe (Maybe Text)) (Maybe (Maybe Text))
    | ScriptFields (Maybe (Map Text Text))
    | DependencyFields InstallableField (Maybe ExternalDependency)

data Manifest = Manifest
    { Manifest -> Maybe Text
manifestName :: Maybe Text
    , Manifest -> Maybe Text
manifestVersion :: Maybe Text
    , Manifest -> Maybe Dist
manifestDist :: Maybe Dist
    , Manifest -> Availability
manifestAvailability :: Availability
    , Manifest -> Maybe (Maybe Bool)
manifestInstallScript :: Maybe (Maybe Bool)
    , Manifest -> Maybe (Map Text Text)
manifestScripts :: Maybe (Map Text Text)
    , Manifest -> Maybe (Maybe License)
manifestLicense :: Maybe (Maybe License)
    , Manifest -> Bool
manifestPublisher :: Bool
    , Manifest -> Maybe ExternalDependency
manifestExternal :: Maybe ExternalDependency
    }

-- | The optional replacement member follows 'newWriter', including original-author diagnostics.
newVersionWriter :: Maybe (Entry, Entry) -> ST st (VersionWriter st)
newVersionWriter :: forall st. Maybe (Entry, Entry) -> ST st (VersionWriter st)
newVersionWriter Maybe (Entry, Entry)
added = Writer st -> MutVar st Role -> VersionWriter st
forall st. Writer st -> MutVar st Role -> VersionWriter st
VersionWriter (Writer st -> MutVar st Role -> VersionWriter st)
-> ST st (Writer st) -> ST st (MutVar st Role -> VersionWriter st)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Entry, Entry) -> ST st (Writer st)
forall st. Maybe (Entry, Entry) -> ST st (Writer st)
newWriter Maybe (Entry, Entry)
added ST st (MutVar st Role -> VersionWriter st)
-> ST st (MutVar st Role) -> ST st (VersionWriter st)
forall a b. ST st (a -> b) -> ST st a -> ST st b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Role -> ST st (MutVar (PrimState (ST st)) Role)
forall (m :: * -> *) a.
PrimMonad m =>
a -> m (MutVar (PrimState m) a)
newMutVar Role
Release

-- | Seal with the existing codec and reset the observer for the next release.
sealVersion :: VersionWriter st -> [Text] -> ST st Packed
sealVersion :: forall st. VersionWriter st -> [Text] -> ST st Packed
sealVersion VersionWriter st
writer [Text]
path = do
    sealed <- Writer st -> [Text] -> ST st Packed
forall st. Writer st -> [Text] -> ST st Packed
sealValue (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) [Text]
path
    writeMutVar (nextRole writer) Release
    pure sealed

-- | Discard both the packed scratch and the next value's observed role.
discardVersion :: VersionWriter st -> ST st ()
discardVersion :: forall st. VersionWriter st -> ST st ()
discardVersion VersionWriter st
writer = Writer st -> ST st ()
forall st. Writer st -> ST st ()
discard (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) ST st () -> ST st () -> ST st ()
forall a b. ST st a -> ST st b -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MutVar (PrimState (ST st)) Role -> Role -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer) Role
Release

-- | Successful facts retain only hook presence in 'vmScripts', represented by empty commands.
versionFacts :: VersionValue -> Maybe VersionManifest
versionFacts :: VersionValue -> Maybe VersionManifest
versionFacts = \case
    ReleaseValue Maybe VersionManifest
facts -> Maybe VersionManifest
facts
    VersionValue
_ -> Maybe VersionManifest
forall a. Maybe a
Nothing

instance Build (VersionWriter st) (ST st (Steps (ST st) s)) where
    type Built (VersionWriter st) = VersionValue
    type Fields (VersionWriter st) = VersionFrame
    type Items (VersionWriter st) = Int
    sharedString :: VersionWriter st
-> Entry
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
sharedString VersionWriter st
writer Entry
entry Built (VersionWriter st) -> ST st (Steps (ST st) s)
next =
        Writer st
-> Entry
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Entry -> (Built b -> r) -> r
sharedString (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Entry
entry ((Built (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \() ->
            VersionWriter st -> Text -> Value -> ST st VersionValue
forall st. VersionWriter st -> Text -> Value -> ST st VersionValue
observeString VersionWriter st
writer (Entry -> Text
entryText Entry
entry) (Entry -> Value
entryString Entry
entry) ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next
    ownString :: VersionWriter st
-> Name
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
ownString VersionWriter st
writer Name
name Built (VersionWriter st) -> ST st (Steps (ST st) s)
next =
        Writer st
-> Name
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Name -> (Built b -> r) -> r
ownString (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Name
name ((Built (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \() ->
            VersionWriter st -> Text -> Value -> ST st VersionValue
forall st. VersionWriter st -> Text -> Value -> ST st VersionValue
observeString VersionWriter st
writer (Name -> Text
nameText Name
name) (Text -> Value
String (Name -> Text
nameText Name
name)) ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next
    integer :: VersionWriter st
-> Int
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
integer VersionWriter st
writer Int
number Built (VersionWriter st) -> ST st (Steps (ST st) s)
next =
        Writer st
-> Int
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Int -> (Built b -> r) -> r
integer (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Int
number (\() -> VersionWriter st -> VersionValue -> ST st VersionValue
forall st. VersionWriter st -> VersionValue -> ST st VersionValue
observeScalar VersionWriter st
writer (Int -> VersionValue
IntegerValue Int
number) ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next)
    whole :: VersionWriter st
-> Value
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
whole VersionWriter st
writer Value
value Built (VersionWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Value
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Value -> (Built b -> r) -> r
whole (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Value
value ((Built (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \() -> case Value
value of
        String Text
text -> VersionWriter st -> Text -> Value -> ST st VersionValue
forall st. VersionWriter st -> Text -> Value -> ST st VersionValue
observeString VersionWriter st
writer Text
text Value
value ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next
        Value
_ -> VersionWriter st -> VersionValue -> ST st VersionValue
forall st. VersionWriter st -> VersionValue -> ST st VersionValue
observeScalar VersionWriter st
writer (Value -> VersionValue
ScalarValue Value
value) ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next
    emptyContainer :: VersionWriter st
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
emptyContainer VersionWriter st
writer Built (VersionWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> (Built b -> r) -> r
emptyContainer (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) (\() -> VersionWriter st -> VersionValue -> ST st VersionValue
forall st. VersionWriter st -> VersionValue -> ST st VersionValue
observeScalar VersionWriter st
writer (Value -> VersionValue
ScalarValue (Array -> Value
Array Array
forall a. Monoid a => a
mempty)) ST st VersionValue
-> (VersionValue -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. ST st a -> (a -> ST st b) -> ST st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Built (VersionWriter st) -> ST st (Steps (ST st) s)
VersionValue -> ST st (Steps (ST st) s)
next)
    openObject :: VersionWriter st
-> (Fields (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
openObject VersionWriter st
writer Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> (Fields b -> r) -> r
openObject (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) ((Fields (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \Fields (Writer st)
frame -> do
        role <- MutVar (PrimState (ST st)) Role -> ST st Role
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer)
        case role of
            Role
Ignore -> () -> ST st ()
forall a. a -> ST st a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
            Role
_ -> MutVar (PrimState (ST st)) Role -> Role -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer) Role
Ignore
        next $! case fieldsFor role of
            Just ObservedFields
fields -> Frame -> ObservedFields -> Set Text -> VersionFrame
VersionFrame Fields (Writer st)
Frame
frame ObservedFields
fields Set Text
forall a. Monoid a => a
mempty
            Maybe ObservedFields
Nothing -> Frame -> VersionValue -> VersionFrame
IgnoredFrame Fields (Writer st)
Frame
frame (VersionValue -> VersionFrame) -> VersionValue -> VersionFrame
forall a b. (a -> b) -> a -> b
$ case Role
role of
                Role
Ignore -> VersionValue
Unobserved
                Role
_ -> Value -> VersionValue
ScalarValue (Object -> Value
Object Object
forall a. Monoid a => a
mempty)
    beginMember :: VersionWriter st
-> MemberKey
-> Fields (VersionWriter st)
-> (Bool -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
beginMember VersionWriter st
writer MemberKey
key Fields (VersionWriter st)
frame Bool -> ST st (Steps (ST st) s)
next = case Fields (VersionWriter st)
frame of
        IgnoredFrame Frame
packed VersionValue
_ -> Writer st
-> MemberKey
-> Fields (Writer st)
-> (Bool -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Fields b -> (Bool -> r) -> r
beginMember (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) MemberKey
key Fields (Writer st)
Frame
packed Bool -> ST st (Steps (ST st) s)
next
        VersionFrame Frame
packed ObservedFields
fields Set Text
seen ->
            Writer st
-> MemberKey
-> Fields (Writer st)
-> (Bool -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Fields b -> (Bool -> r) -> r
beginMember (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) MemberKey
key Fields (Writer st)
Frame
packed ((Bool -> ST st (Steps (ST st) s)) -> ST st (Steps (ST st) s))
-> (Bool -> ST st (Steps (ST st) s)) -> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \Bool
repeated -> do
                let duplicate :: Bool
duplicate =
                        Bool
repeated Bool -> Bool -> Bool
|| case MemberKey
key of
                            OwnKey Key
_ -> Text -> Set Text -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member (MemberKey -> Text
memberText MemberKey
key) Set Text
seen
                            SharedKey Entry
_ -> Bool
False
                -- A role written lazily would allocate a thunk for every member, every dependency spec included.
                MutVar (PrimState (ST st)) Role -> Role -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer) (Role -> ST st ()) -> Role -> ST st ()
forall a b. (a -> b) -> a -> b
$! if Bool
duplicate then Role
Ignore else ObservedFields -> Text -> Role
memberRole ObservedFields
fields (MemberKey -> Text
memberText MemberKey
key)
                Bool -> ST st (Steps (ST st) s)
next Bool
duplicate
    addMember :: VersionWriter st
-> MemberKey
-> Built (VersionWriter st)
-> Fields (VersionWriter st)
-> (Fields (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
addMember VersionWriter st
writer MemberKey
key Built (VersionWriter st)
value Fields (VersionWriter st)
frame Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next = case Fields (VersionWriter st)
frame of
        -- The packed writer returns the same frame after each member.
        IgnoredFrame Frame
packed VersionValue
_ -> Writer st
-> MemberKey
-> Built (Writer st)
-> Fields (Writer st)
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Built b -> Fields b -> (Fields b -> r) -> r
addMember (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) MemberKey
key () Fields (Writer st)
Frame
packed (ST st (Steps (ST st) s) -> Frame -> ST st (Steps (ST st) s)
forall a b. a -> b -> a
const (Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame))
        VersionFrame Frame
packed ObservedFields
fields Set Text
seen ->
            Writer st
-> MemberKey
-> Built (Writer st)
-> Fields (Writer st)
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> MemberKey -> Built b -> Fields b -> (Fields b -> r) -> r
addMember (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) MemberKey
key () Fields (Writer st)
Frame
packed ((Fields (Writer st) -> ST st (Steps (ST st) s))
 -> ST st (Steps (ST st) s))
-> (Fields (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall a b. (a -> b) -> a -> b
$ \Fields (Writer st)
packed' ->
                case (ObservedFields
fields, Built (VersionWriter st)
VersionValue
value, MemberKey
key) of
                    (ReleaseFields{}, VersionValue
Unobserved, MemberKey
_) -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame
                    (DistFields{}, VersionValue
Unobserved, MemberKey
_) -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame
                    (LicenseFields{}, VersionValue
Unobserved, MemberKey
_) -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame
                    (PersonFields{}, VersionValue
Unobserved, MemberKey
_) -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame
                    -- A spec under a table key changes nothing, and the packed writer already knows the key.
                    (ObservedFields
_, VersionValue
NoExternalSpec, SharedKey Entry
_) -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next Fields (VersionWriter st)
frame
                    (ObservedFields, VersionValue, MemberKey)
_ -> Fields (VersionWriter st) -> ST st (Steps (ST st) s)
next (Frame -> ObservedFields -> Set Text -> VersionFrame
VersionFrame Fields (Writer st)
Frame
packed' (Text -> VersionValue -> ObservedFields -> ObservedFields
addField (MemberKey -> Text
memberText MemberKey
key) Built (VersionWriter st)
VersionValue
value ObservedFields
fields) (MemberKey -> VersionValue -> Set Text -> Set Text
rememberOwn MemberKey
key Built (VersionWriter st)
VersionValue
value Set Text
seen))
    dropValue :: VersionWriter st
-> Built (VersionWriter st)
-> ST st (Steps (ST st) s)
-> ST st (Steps (ST st) s)
dropValue VersionWriter st
writer Built (VersionWriter st)
_ = Writer st
-> Built (Writer st)
-> ST st (Steps (ST st) s)
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Built b -> r -> r
dropValue (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) ()
    closeObject :: VersionWriter st
-> Fields (VersionWriter st)
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
closeObject VersionWriter st
writer Fields (VersionWriter st)
frame Built (VersionWriter st) -> ST st (Steps (ST st) s)
next = case Fields (VersionWriter st)
frame of
        IgnoredFrame Frame
packed VersionValue
value -> Writer st
-> Fields (Writer st)
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Fields b -> (Built b -> r) -> r
closeObject (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Fields (Writer st)
Frame
packed (\() -> Built (VersionWriter st) -> ST st (Steps (ST st) s)
next Built (VersionWriter st)
VersionValue
value)
        VersionFrame Frame
packed ObservedFields
fields Set Text
_ -> Writer st
-> Fields (Writer st)
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Fields b -> (Built b -> r) -> r
closeObject (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Fields (Writer st)
Frame
packed (\() -> Built (VersionWriter st) -> ST st (Steps (ST st) s)
next (ObservedFields -> VersionValue
finishFields ObservedFields
fields))
    openArray :: VersionWriter st
-> (Items (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
openArray VersionWriter st
writer Items (VersionWriter st) -> ST st (Steps (ST st) s)
next = do
        MutVar (PrimState (ST st)) Role -> Role -> ST st ()
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> a -> m ()
writeMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer) Role
Ignore
        Writer st
-> (Items (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> (Items b -> r) -> r
openArray (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Items (Writer st) -> ST st (Steps (ST st) s)
Items (VersionWriter st) -> ST st (Steps (ST st) s)
next
    addItem :: VersionWriter st
-> Built (VersionWriter st)
-> Items (VersionWriter st)
-> (Items (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
addItem VersionWriter st
writer Built (VersionWriter st)
_ = Writer st
-> Built (Writer st)
-> Items (Writer st)
-> (Items (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r.
Build b r =>
b -> Built b -> Items b -> (Items b -> r) -> r
addItem (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) ()
    closeArray :: VersionWriter st
-> Int
-> Items (VersionWriter st)
-> (Built (VersionWriter st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
closeArray VersionWriter st
writer Int
count Items (VersionWriter st)
items Built (VersionWriter st) -> ST st (Steps (ST st) s)
next = Writer st
-> Int
-> Items (Writer st)
-> (Built (Writer st) -> ST st (Steps (ST st) s))
-> ST st (Steps (ST st) s)
forall b r. Build b r => b -> Int -> Items b -> (Built b -> r) -> r
closeArray (VersionWriter st -> Writer st
forall st. VersionWriter st -> Writer st
packedWriter VersionWriter st
writer) Int
count Items (Writer st)
Items (VersionWriter st)
items (\() -> Built (VersionWriter st) -> ST st (Steps (ST st) s)
next (Value -> VersionValue
ScalarValue (Array -> Value
Array Array
forall a. Monoid a => a
mempty)))
    {-# INLINE sharedString #-}
    {-# INLINE ownString #-}
    {-# INLINE integer #-}
    {-# INLINE whole #-}
    {-# INLINE emptyContainer #-}
    {-# INLINE openObject #-}
    {-# INLINE beginMember #-}
    {-# INLINE addMember #-}
    {-# INLINE dropValue #-}
    {-# INLINE closeObject #-}
    {-# INLINE openArray #-}
    {-# INLINE addItem #-}
    {-# INLINE closeArray #-}

-- A registry spec must classify without allocating: the npm full reads' allocation budgets hold a 1% margin.
observeString :: VersionWriter st -> Text -> Value -> ST st VersionValue
observeString :: forall st. VersionWriter st -> Text -> Value -> ST st VersionValue
observeString VersionWriter st
writer Text
text Value
value = do
    role <- MutVar (PrimState (ST st)) Role -> ST st Role
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer)
    pure $! case role of
        Role
Command -> VersionValue
StringCommand
        Role
DependencySpec -> VersionValue
-> (ExternalSource -> VersionValue)
-> Maybe ExternalSource
-> VersionValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe VersionValue
NoExternalSpec ExternalSource -> VersionValue
ExternalSpec (Text -> Maybe ExternalSource
externalSource Text
text)
        Role
Ignore -> VersionValue
Unobserved
        Role
_ -> Value -> VersionValue
ScalarValue Value
value
{-# INLINE observeString #-}

observeScalar :: VersionWriter st -> VersionValue -> ST st VersionValue
observeScalar :: forall st. VersionWriter st -> VersionValue -> ST st VersionValue
observeScalar VersionWriter st
writer VersionValue
value = do
    role <- MutVar (PrimState (ST st)) Role -> ST st Role
forall (m :: * -> *) a.
PrimMonad m =>
MutVar (PrimState m) a -> m a
readMutVar (VersionWriter st -> MutVar st Role
forall st. VersionWriter st -> MutVar st Role
nextRole VersionWriter st
writer)
    pure $! case role of
        Role
DependencySpec -> VersionValue
NoExternalSpec
        Role
Ignore -> VersionValue
Unobserved
        Role
_ -> VersionValue
value
{-# INLINE observeScalar #-}

rememberOwn :: MemberKey -> VersionValue -> Set Text -> Set Text
rememberOwn :: MemberKey -> VersionValue -> Set Text -> Set Text
rememberOwn MemberKey
key VersionValue
value Set Text
seen = case (MemberKey
key, VersionValue
value) of
    (OwnKey Key
_, VersionValue
Unobserved) -> Set Text
seen
    (OwnKey Key
_, VersionValue
_) -> Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert (MemberKey -> Text
memberText MemberKey
key) Set Text
seen
    (SharedKey Entry
_, VersionValue
_) -> Set Text
seen

fieldsFor :: Role -> Maybe ObservedFields
fieldsFor :: Role -> Maybe ObservedFields
fieldsFor = \case
    Role
Release -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (Manifest -> ObservedFields
ReleaseFields (Maybe Text
-> Maybe Text
-> Maybe Dist
-> Availability
-> Maybe (Maybe Bool)
-> Maybe (Map Text Text)
-> Maybe (Maybe License)
-> Bool
-> Maybe ExternalDependency
-> Manifest
Manifest Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Dist
forall a. Maybe a
Nothing Availability
Available (Maybe Bool -> Maybe (Maybe Bool)
forall a. a -> Maybe a
Just Maybe Bool
forall a. Maybe a
Nothing) (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
forall a. Monoid a => a
mempty) (Maybe License -> Maybe (Maybe License)
forall a. a -> Maybe a
Just Maybe License
forall a. Maybe a
Nothing) Bool
True Maybe ExternalDependency
forall a. Maybe a
Nothing))
    DependencyMap InstallableField
field -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (InstallableField -> Maybe ExternalDependency -> ObservedFields
DependencyFields InstallableField
field Maybe ExternalDependency
forall a. Maybe a
Nothing)
    Role
Scripts -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (Maybe (Map Text Text) -> ObservedFields
ScriptFields (Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just Map Text Text
forall a. Monoid a => a
mempty))
    Role
DistObject -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields Maybe Text
forall a. Maybe a
Nothing (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing) (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing) Maybe Int
forall a. Maybe a
Nothing)
    Role
LicenseObject -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
LicenseFields (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing) (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing))
    Role
PersonObject -> ObservedFields -> Maybe ObservedFields
forall a. a -> Maybe a
Just (Maybe (Maybe Text)
-> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
PersonFields (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing) (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing) (Maybe Text -> Maybe (Maybe Text)
forall a. a -> Maybe a
Just Maybe Text
forall a. Maybe a
Nothing))
    Role
_ -> Maybe ObservedFields
forall a. Maybe a
Nothing

memberRole :: ObservedFields -> Text -> Role
memberRole :: ObservedFields -> Text -> Role
memberRole ObservedFields
fields Text
key = case ObservedFields
fields of
    ReleaseFields Manifest
_ -> case Text
key of
        Text
"dist" -> Role
DistObject
        Text
"license" -> Role
LicenseObject
        Text
"_npmUser" -> Role
PersonObject
        Text
"scripts" -> Role
Scripts
        Text
"name" -> Role
ScalarField
        Text
"version" -> Role
ScalarField
        Text
"deprecated" -> Role
ScalarField
        Text
"hasInstallScript" -> Role
ScalarField
        Text
"dependencies" -> InstallableField -> Role
DependencyMap InstallableField
Dependencies
        Text
"optionalDependencies" -> InstallableField -> Role
DependencyMap InstallableField
OptionalDependencies
        Text
"peerDependencies" -> InstallableField -> Role
DependencyMap InstallableField
PeerDependencies
        Text
_ -> Role
Ignore
    DistFields{} -> if Text
key Text -> [Text] -> Bool
forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` [Text]
distFields then Role
ScalarField else Role
Ignore
    LicenseFields{} -> if Text
key Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"type" Bool -> Bool -> Bool
|| Text
key Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"url" then Role
ScalarField else Role
Ignore
    PersonFields{} -> if Text
key Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"name" Bool -> Bool -> Bool
|| Text
key Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"email" Bool -> Bool -> Bool
|| Text
key Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"url" then Role
ScalarField else Role
Ignore
    ScriptFields Maybe (Map Text Text)
_ -> Role
Command
    DependencyFields{} -> Role
DependencySpec

addField :: Text -> VersionValue -> ObservedFields -> ObservedFields
addField :: Text -> VersionValue -> ObservedFields -> ObservedFields
addField Text
"unpackedSize" (IntegerValue Int
number) (DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity Maybe Int
_) =
    Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity (Maybe Int -> Maybe Int
forall a. NFData a => a -> a
force (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
number))
addField Text
key (IntegerValue Int
number) ObservedFields
fields = Text -> VersionValue -> ObservedFields -> ObservedFields
addField Text
key (Value -> VersionValue
ScalarValue (Scientific -> Value
Number (Int -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
number))) ObservedFields
fields
addField Text
key VersionValue
value ObservedFields
observed = case ObservedFields
observed of
    ReleaseFields Manifest
manifest -> Manifest -> ObservedFields
ReleaseFields (Text -> VersionValue -> Manifest -> Manifest
addManifest Text
key VersionValue
value Manifest
manifest)
    fields :: ObservedFields
fields@(DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity Maybe Int
size) -> case (Text
key, VersionValue
value) of
        (Text
"tarball", ScalarValue Value
scalar) -> Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields ((Value -> Parser Text) -> Value -> Maybe Text
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity Maybe Int
size
        (Text
"shasum", ScalarValue Value
scalar) -> Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields Maybe Text
tarball ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe (Maybe Text)
integrity Maybe Int
size
        (Text
"integrity", ScalarValue Value
scalar) -> Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe Int
size
        (Text
"unpackedSize", ScalarValue Value
scalar) -> Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe Int
-> ObservedFields
DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity (Maybe Int -> Maybe Int
forall a. NFData a => a -> a
force ((Value -> Parser Int) -> Value -> Maybe Int
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar))
        (Text, VersionValue)
_ -> ObservedFields
fields
    fields :: ObservedFields
fields@(LicenseFields Maybe (Maybe Text)
kind Maybe (Maybe Text)
url) -> case (Text
key, VersionValue
value) of
        (Text
"type", ScalarValue Value
scalar) -> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
LicenseFields ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe (Maybe Text)
url
        (Text
"url", ScalarValue Value
scalar) -> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
LicenseFields Maybe (Maybe Text)
kind ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar)
        (Text, VersionValue)
_ -> ObservedFields
fields
    fields :: ObservedFields
fields@(PersonFields Maybe (Maybe Text)
name Maybe (Maybe Text)
email Maybe (Maybe Text)
url) -> case (Text
key, VersionValue
value) of
        (Text
"name", ScalarValue Value
scalar) -> Maybe (Maybe Text)
-> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
PersonFields ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe (Maybe Text)
email Maybe (Maybe Text)
url
        (Text
"email", ScalarValue Value
scalar) -> Maybe (Maybe Text)
-> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
PersonFields Maybe (Maybe Text)
name ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar) Maybe (Maybe Text)
url
        (Text
"url", ScalarValue Value
scalar) -> Maybe (Maybe Text)
-> Maybe (Maybe Text) -> Maybe (Maybe Text) -> ObservedFields
PersonFields Maybe (Maybe Text)
name Maybe (Maybe Text)
email ((Value -> Parser (Maybe Text)) -> Value -> Maybe (Maybe Text)
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
scalar)
        (Text, VersionValue)
_ -> ObservedFields
fields
    ScriptFields Maybe (Map Text Text)
scripts -> Maybe (Map Text Text) -> ObservedFields
ScriptFields (Maybe (Map Text Text) -> ObservedFields)
-> Maybe (Map Text Text) -> ObservedFields
forall a b. (a -> b) -> a -> b
$ do
        held <- Maybe (Map Text Text)
scripts
        case value of
            VersionValue
StringCommand -> Map Text Text -> Maybe (Map Text Text)
forall a. a -> Maybe a
Just (Text -> Map Text Text -> Map Text Text
keepHook Text
key Map Text Text
held)
            ScalarValue Value
scalar -> (Value -> Parser Text) -> Value -> Maybe Text
forall a b. (a -> Parser b) -> a -> Maybe b
parseMaybe (forall a. FromJSON a => Value -> Parser a
parseJSON @Text) Value
scalar Maybe Text -> Map Text Text -> Maybe (Map Text Text)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Text -> Map Text Text -> Map Text Text
keepHook Text
key Map Text Text
held
            VersionValue
_ -> Maybe (Map Text Text)
forall a. Maybe a
Nothing
    fields :: ObservedFields
fields@(DependencyFields InstallableField
field Maybe ExternalDependency
held) -> case VersionValue
value of
        -- Chosen before it is wrapped, so a map of external specs holds no chain of thunks.
        ExternalSpec ExternalSource
source ->
            let found :: ExternalDependency
found = InstallableField -> Text -> ExternalSource -> ExternalDependency
ExternalDependency InstallableField
field Text
key ExternalSource
source
                !chosen :: ExternalDependency
chosen = ExternalDependency
-> (ExternalDependency -> ExternalDependency)
-> Maybe ExternalDependency
-> ExternalDependency
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ExternalDependency
found (ExternalDependency -> ExternalDependency -> ExternalDependency
`earlierDependency` ExternalDependency
found) Maybe ExternalDependency
held
             in InstallableField -> Maybe ExternalDependency -> ObservedFields
DependencyFields InstallableField
field (ExternalDependency -> Maybe ExternalDependency
forall a. a -> Maybe a
Just ExternalDependency
chosen)
        VersionValue
_ -> ObservedFields
fields

keepHook :: Text -> Map Text Text -> Map Text Text
keepHook :: Text -> Map Text Text -> Map Text Text
keepHook Text
key Map Text Text
scripts
    | Text
key Text -> [Text] -> Bool
forall (f :: * -> *) a.
(Foldable f, DisallowElem f, Eq a) =>
a -> f a -> Bool
`elem` [Text]
installHooks = Text -> Text -> Map Text Text -> Map Text Text
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Text
key Text
"" Map Text Text
scripts
    | Bool
otherwise = Map Text Text
scripts

addManifest :: Text -> VersionValue -> Manifest -> Manifest
addManifest :: Text -> VersionValue -> Manifest -> Manifest
addManifest Text
key VersionValue
value Manifest
manifest = case (Text
key, VersionValue
value) of
    (Text
"dist", DistValue Maybe Dist
dist) -> Manifest
manifest{manifestDist = dist}
    (Text
"license", LicenseValue Maybe License
licence) -> Manifest
manifest{manifestLicense = Just <$> licence}
    (Text
"_npmUser", PersonValue Bool
valid) -> Manifest
manifest{manifestPublisher = valid}
    (Text
"scripts", ScriptValue Maybe (Map Text Text)
scripts) -> Manifest
manifest{manifestScripts = scripts}
    (Text
_, ExternalMap ExternalDependency
found) ->
        let !chosen :: ExternalDependency
chosen = ExternalDependency
-> (ExternalDependency -> ExternalDependency)
-> Maybe ExternalDependency
-> ExternalDependency
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ExternalDependency
found (ExternalDependency -> ExternalDependency -> ExternalDependency
`earlierDependency` ExternalDependency
found) (Manifest -> Maybe ExternalDependency
manifestExternal Manifest
manifest)
         in Manifest
manifest{manifestExternal = Just chosen}
    (Text
_, ScalarValue Value
scalar) -> case Text
key of
        Text
"name" -> Manifest
manifest{manifestName = parseMaybe parseJSON scalar}
        Text
"version" -> Manifest
manifest{manifestVersion = parseMaybe parseJSON scalar}
        Text
"dist" -> Manifest
manifest{manifestDist = parseMaybe parseJSON scalar}
        Text
"deprecated" -> Manifest
manifest{manifestAvailability = availability (Just scalar)}
        Text
"hasInstallScript" -> Manifest
manifest{manifestInstallScript = parseMaybe parseJSON scalar}
        Text
"scripts" -> Manifest
manifest{manifestScripts = fromMaybe mempty <$> parseMaybe (parseJSON @(Maybe (Map Text Text))) scalar}
        Text
"license" -> Manifest
manifest{manifestLicense = parseMaybe parseJSON scalar}
        Text
"_npmUser" -> Manifest
manifest{manifestPublisher = isJust (parseMaybe (parseJSON @(Maybe Person)) scalar)}
        Text
_ -> Manifest
manifest
    (Text, VersionValue)
_ -> Manifest
manifest

finishFields :: ObservedFields -> VersionValue
finishFields :: ObservedFields -> VersionValue
finishFields = \case
    ReleaseFields Manifest
manifest -> Maybe VersionManifest -> VersionValue
ReleaseValue (Maybe VersionManifest -> VersionValue)
-> Maybe VersionManifest -> VersionValue
forall a b. (a -> b) -> a -> b
$ do
        Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Manifest -> Bool
manifestPublisher Manifest
manifest)
        Text
-> Text
-> Dist
-> Availability
-> Maybe Bool
-> Map Text Text
-> Maybe License
-> Maybe ExternalDependency
-> VersionManifest
VersionManifest
            (Text
 -> Text
 -> Dist
 -> Availability
 -> Maybe Bool
 -> Map Text Text
 -> Maybe License
 -> Maybe ExternalDependency
 -> VersionManifest)
-> Maybe Text
-> Maybe
     (Text
      -> Dist
      -> Availability
      -> Maybe Bool
      -> Map Text Text
      -> Maybe License
      -> Maybe ExternalDependency
      -> VersionManifest)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Manifest -> Maybe Text
manifestName Manifest
manifest
            Maybe
  (Text
   -> Dist
   -> Availability
   -> Maybe Bool
   -> Map Text Text
   -> Maybe License
   -> Maybe ExternalDependency
   -> VersionManifest)
-> Maybe Text
-> Maybe
     (Dist
      -> Availability
      -> Maybe Bool
      -> Map Text Text
      -> Maybe License
      -> Maybe ExternalDependency
      -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Manifest -> Maybe Text
manifestVersion Manifest
manifest
            Maybe
  (Dist
   -> Availability
   -> Maybe Bool
   -> Map Text Text
   -> Maybe License
   -> Maybe ExternalDependency
   -> VersionManifest)
-> Maybe Dist
-> Maybe
     (Availability
      -> Maybe Bool
      -> Map Text Text
      -> Maybe License
      -> Maybe ExternalDependency
      -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Manifest -> Maybe Dist
manifestDist Manifest
manifest
            Maybe
  (Availability
   -> Maybe Bool
   -> Map Text Text
   -> Maybe License
   -> Maybe ExternalDependency
   -> VersionManifest)
-> Maybe Availability
-> Maybe
     (Maybe Bool
      -> Map Text Text
      -> Maybe License
      -> Maybe ExternalDependency
      -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Availability -> Maybe Availability
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Manifest -> Availability
manifestAvailability Manifest
manifest)
            Maybe
  (Maybe Bool
   -> Map Text Text
   -> Maybe License
   -> Maybe ExternalDependency
   -> VersionManifest)
-> Maybe (Maybe Bool)
-> Maybe
     (Map Text Text
      -> Maybe License -> Maybe ExternalDependency -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Manifest -> Maybe (Maybe Bool)
manifestInstallScript Manifest
manifest
            Maybe
  (Map Text Text
   -> Maybe License -> Maybe ExternalDependency -> VersionManifest)
-> Maybe (Map Text Text)
-> Maybe
     (Maybe License -> Maybe ExternalDependency -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Manifest -> Maybe (Map Text Text)
manifestScripts Manifest
manifest
            Maybe
  (Maybe License -> Maybe ExternalDependency -> VersionManifest)
-> Maybe (Maybe License)
-> Maybe (Maybe ExternalDependency -> VersionManifest)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Manifest -> Maybe (Maybe License)
manifestLicense Manifest
manifest
            Maybe (Maybe ExternalDependency -> VersionManifest)
-> Maybe (Maybe ExternalDependency) -> Maybe VersionManifest
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe ExternalDependency -> Maybe (Maybe ExternalDependency)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Manifest -> Maybe ExternalDependency
manifestExternal Manifest
manifest)
    DistFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity Maybe Int
size -> Maybe Dist -> VersionValue
DistValue (Maybe Text
-> Maybe (Maybe Text)
-> Maybe (Maybe Text)
-> Maybe (Maybe Int)
-> Maybe Dist
forall (f :: * -> *).
Applicative f =>
f Text
-> f (Maybe Text) -> f (Maybe Text) -> f (Maybe Int) -> f Dist
distFromFields Maybe Text
tarball Maybe (Maybe Text)
shasum Maybe (Maybe Text)
integrity (Maybe Int -> Maybe (Maybe Int)
forall a. a -> Maybe a
Just Maybe Int
size))
    LicenseFields Maybe (Maybe Text)
kind Maybe (Maybe Text)
url -> Maybe License -> VersionValue
LicenseValue (Maybe (Maybe Text) -> Maybe (Maybe Text) -> Maybe License
forall (f :: * -> *).
Applicative f =>
f (Maybe Text) -> f (Maybe Text) -> f License
licenseFromFields Maybe (Maybe Text)
kind Maybe (Maybe Text)
url)
    PersonFields Maybe (Maybe Text)
name Maybe (Maybe Text)
email Maybe (Maybe Text)
url -> Bool -> VersionValue
PersonValue (Maybe Person -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (Maybe Text)
-> Maybe (Maybe Text) -> Maybe (Maybe Text) -> Maybe Person
forall (f :: * -> *).
Applicative f =>
f (Maybe Text) -> f (Maybe Text) -> f (Maybe Text) -> f Person
personFromFields Maybe (Maybe Text)
name Maybe (Maybe Text)
email Maybe (Maybe Text)
url))
    ScriptFields Maybe (Map Text Text)
scripts -> Maybe (Map Text Text) -> VersionValue
ScriptValue Maybe (Map Text Text)
scripts
    DependencyFields InstallableField
_ Maybe ExternalDependency
held -> VersionValue
-> (ExternalDependency -> VersionValue)
-> Maybe ExternalDependency
-> VersionValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe VersionValue
NoExternalSpec ExternalDependency -> VersionValue
ExternalMap Maybe ExternalDependency
held