LibAcc: 0.7353=25/34, ProjAcc: 0.5000=2/4, Missing: 149
Module: spec/index_spec
let 𝓟1{beforeEachProviders};
let 𝓟2{it};
let 𝓟3{describe};
let 𝓟4{expect};
let 𝓟5{inject};
𝓛10097{require}(𝓛8743{String})
function 𝓟6{CONSTRUCTOR} (𝓟7{afield}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]10051{String})): (𝓟[ty]11{TypeB})
{
const 𝓟[ty]11{TypeB};
const 𝓟[ty]11{TypeB};
𝓟[ty]11{TypeB}.afield ⟵ 𝓟7{afield};
}
class 𝓟[ty]11{TypeB}{
𝓟13{afield}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String});
}
function 𝓟14{CONSTRUCTOR} (𝓟15{astring}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]10051{String}),𝓟16{anumber}: 𝓛[ty]8655{Number},𝓟17{adate}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]8635{Date}),𝓟18{aclass}: (𝓟[ty]61{MockStorage} ≠ 𝓟[ty]11{TypeB})): (𝓟[ty]36{TypeA})
{
const 𝓟[ty]36{TypeA};
const 𝓟[ty]36{TypeA};
𝓟[ty]36{TypeA}.anumber ⟵ 𝓟16{anumber};
𝓟[ty]36{TypeA}.adate ⟵ 𝓟17{adate};
𝓟[ty]36{TypeA}.astring ⟵ 𝓟15{astring};
𝓟[ty]36{TypeA}.aclass ⟵ 𝓟18{aclass};
}
function 𝓟22{reviver} (𝓟23{key}: 𝓛[ty]10051{String},𝓟24{value}: [OOV]any): (𝓟25: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟24{value}),𝓛8743{String}))
{
if (𝓟24{value}.afield)
{
return 𝓟25 = 𝓟6{CONSTRUCTOR}(𝓟24{value}.afield)
}
else
{
return 𝓟25 = 𝓟14{CONSTRUCTOR}(𝓟24{value}.astring,𝓟24{value}.anumber,𝓟24{value}.adate,𝓟24{value}.aclass)
}
}
return 𝓟25 = 𝓟207{dateReviver}(𝓟23{key},𝓟24{value})
}
function 𝓟26{replacer} (𝓟27{key}: 𝓛[ty]10051{String},𝓟28{value}: [OOV]any): (𝓟29: [OOV]any)
{
if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟27{key},𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓟27{key},𝓛8743{String})))
{
return 𝓟29 = 𝓛12643{undefined}
}
return 𝓟29 = 𝓟28{value}
}
function 𝓟30{serialize} (𝓟31{a}: 𝓟[ty]36{TypeA}): (𝓟32: 𝓛[ty]10051{String})
{
return 𝓟32 = 𝓛8756{JSON}.stringify(𝓟31{a})
}
function 𝓟33{deserialize} (𝓟34{json}: [OOV]any): (𝓟35: 𝓟[ty]36{TypeA})
{
return 𝓟35 = 𝓟14{CONSTRUCTOR}(𝓟34{json}.astring,𝓟34{json}.anumber,𝓟34{json}.adate,𝓟6{CONSTRUCTOR}(𝓟34{json}.aclass.afield))
}
class 𝓟[ty]36{TypeA}{
𝓟38{astring}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]10051{String});
𝓟39{anumber}: 𝓛[ty]8655{Number};
𝓟40{adate}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]8635{Date});
𝓟41{aclass}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]11{TypeB});
}
const 𝓟42{key}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟43{CONSTRUCTOR} (): (𝓟[ty]55{TypeC})
{
const 𝓟[ty]55{TypeC};
const 𝓟[ty]55{TypeC};
}
function 𝓟47{encrypt} (𝓟48{message}: 𝓛[ty]10051{String}): (𝓟49: [OOV]any)
{
let 𝓟50{secret} = 𝓛1{<UNKNOWN>}.encrypt(𝓟48{message},𝓟42{key});
return 𝓟49 = 𝓟50{secret}.toString()
}
function 𝓟51{decrypt} (𝓟52{message}: 𝓛[ty]10051{String}): (𝓟53: [OOV]any)
{
let 𝓟54{decoded} = 𝓛1{<UNKNOWN>}.decrypt(𝓟52{message},𝓟42{key});
𝓟54{decoded} ⟵ 𝓟54{decoded}.toString(𝓛1{<UNKNOWN>}.Utf8);
return 𝓟53 = 𝓟54{decoded}
}
class 𝓟[ty]55{TypeC} extends 𝓟[ty]36{TypeA}{
}
function 𝓟57{CONSTRUCTOR} (): (𝓟[ty]61{MockStorage})
{
const 𝓟[ty]61{MockStorage};
const 𝓟[ty]61{MockStorage};
}
class 𝓟[ty]61{MockStorage} extends 𝓛[ty]10926{Storage}{
𝓟63{length}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
function 𝓟75{setItem} (𝓟76{key}: 𝓛[ty]10051{String},𝓟77{data}: (𝓟[ty]61{MockStorage} ≠ 𝓛[ty]10051{String})): (𝓟78: 𝓛[ty]10033{Void})
{
𝓟[ty]61{MockStorage}.access(𝓟76{key}) ⟵ 𝓟77{data};
}
function 𝓟72{removeItem} (𝓟73{key}: 𝓛[ty]10051{String}): (𝓟74: 𝓛[ty]10033{Void})
{
𝓟[ty]61{MockStorage}.access(𝓟73{key}) ⟵ 𝓛12643{undefined};
}
function 𝓟64{clear} (): (𝓟65: 𝓛[ty]10033{Void})
{
𝓛8743{String}
}
function 𝓟69{key} (𝓟70{index}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟71: [OOV]any)
{
𝓛8743{String}
}
function 𝓟66{getItem} (𝓟67{key}: 𝓛[ty]10051{String}): (𝓟68: [OOV]any)
{
return 𝓟68 = (𝓟[ty]61{MockStorage}.access(𝓟67{key}) ? 𝓟[ty]61{MockStorage}.access(𝓟67{key}) : 𝓛12643{undefined}
}
}
function 𝓟79{mockStorageKeySerializer} (𝓟80{key}): (𝓟81: [OOV]any)
{
return 𝓟81 = 𝓟80{key}
}
function 𝓟82{$Lambda0} (): (𝓟83: [miss]𝓛[ty]10033{Void})
{
let 𝓟84{t1}: [miss]𝓟[ty]36{TypeA} = 𝓟14{CONSTRUCTOR}(𝓛8743{String},𝓛8745{Number},𝓛8747{Date}.CONSTRUCTOR(𝓛8743{String}),𝓟6{CONSTRUCTOR}(𝓛8743{String}));
let 𝓟85{t1Json}: [miss]𝓛[ty]10051{String} = 𝓛8756{JSON}.stringify(𝓟84{t1});
let 𝓟86{t1Filtered}: [miss]𝓟[ty]36{TypeA} = 𝓟14{CONSTRUCTOR}(𝓛8743{String},𝓛12643{undefined},𝓛12643{undefined},𝓟6{CONSTRUCTOR}(𝓛8743{String}));
let 𝓟87{t1FilteredJson}: [miss]𝓛[ty]10051{String} = 𝓛8756{JSON}.stringify(𝓟86{t1Filtered});
let 𝓟88{t1Simple}: [miss]𝓛[ty]8642{Object} = {astring: 𝓛8743{String},adate: 𝓛8743{String},anumber: 𝓛8745{Number}};
let 𝓟89{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟90{initialStateJson}: [miss]𝓛[ty]10051{String} = 𝓛8756{JSON}.stringify(𝓟89{initialState});
let 𝓟91{undefinedState}: [miss]𝓛[ty]8642{Object} = {state: 𝓛12643{undefined}};
let 𝓟92{undefinedStateJson}: [miss]𝓛[ty]10051{String} = 𝓛8756{JSON}.stringify(𝓟91{undefinedState});
const 𝓟93{primitiveStr}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟94{initialStatePrimitiveStr}: [miss]𝓛[ty]8642{Object} = {state: 𝓟93{primitiveStr}};
function 𝓟95{$Lambda1} (): (𝓟96: [miss]𝓛[ty]10033{Void})
{
let 𝓟97{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟98{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
𝓟259{syncStateUpdate}(𝓟89{initialState},𝓛8757{Array}(𝓛8743{String}),𝓟97{s},𝓟98{skr},𝓛8744{Boolean})
let 𝓟99{raw}: [miss]𝓛[ty]10051{String} = 𝓟97{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟99{raw}).toEqual(𝓟85{t1Json})
let 𝓟100{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓛8757{Array}(𝓛8743{String}),𝓟97{s},𝓟98{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟100{finalState})).toEqual(𝓟90{initialStateJson})
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟100{finalState}.simple,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟95{$Lambda1})
function 𝓟101{$Lambda2} (): (𝓟102: [miss]𝓛[ty]10033{Void})
{
const 𝓟103{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
const 𝓟104{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
𝓟259{syncStateUpdate}(𝓟94{initialStatePrimitiveStr},𝓛8757{Array}(𝓛8743{String}),𝓟103{s},𝓟104{skr},𝓛8744{Boolean})
const 𝓟105{raw}: [miss]𝓛[ty]10051{String} = 𝓟103{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟105{raw}).toEqual(𝓟93{primitiveStr})
const 𝓟106{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓛8757{Array}(𝓛8743{String}),𝓟103{s},𝓟104{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓟106{finalState}.state).toEqual(𝓟93{primitiveStr})
}
𝓟2{it}(𝓛8743{String},𝓟101{$Lambda2})
function 𝓟107{$Lambda3} (): (𝓟108: [miss]𝓛[ty]10033{Void})
{
let 𝓟109{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟110{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟111{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟112{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({state: 𝓛8757{Array}(𝓛8743{String},𝓛8743{String})});
𝓟259{syncStateUpdate}(𝓟111{initialState},𝓟112{keys},𝓟109{s},𝓟110{skr},𝓛8744{Boolean})
let 𝓟113{raw}: [miss]𝓛[ty]10051{String} = 𝓟109{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟113{raw}).toEqual(𝓛8756{JSON}.stringify(𝓟86{t1Filtered}))
let 𝓟114{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟112{keys},𝓟109{s},𝓟110{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟114{finalState})).toEqual(𝓛8756{JSON}.stringify({state: 𝓟86{t1Filtered}}))
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟114{finalState}.state,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟107{$Lambda3})
function 𝓟115{$Lambda4} (): (𝓟116: [miss]𝓛[ty]10033{Void})
{
let 𝓟117{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟118{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟119{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟120{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({state: 𝓟22{reviver}});
𝓟259{syncStateUpdate}(𝓟119{initialState},𝓟120{keys},𝓟117{s},𝓟118{skr},𝓛8744{Boolean})
let 𝓟121{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟120{keys},𝓟117{s},𝓟118{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟121{finalState})).toEqual(𝓛8756{JSON}.stringify(𝓟119{initialState}))
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟121{finalState}.state,𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟121{finalState}.state.aclass,𝓛12643{undefined})).toBeTruthy()
}
𝓟2{it}(𝓛8743{String},𝓟115{$Lambda4})
function 𝓟122{$Lambda5} (): (𝓟123: [miss]𝓛[ty]10033{Void})
{
let 𝓟124{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟125{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟126{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟127{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({state: {reviver: 𝓟22{reviver}}});
𝓟259{syncStateUpdate}(𝓟126{initialState},𝓟127{keys},𝓟124{s},𝓟125{skr},𝓛8744{Boolean})
let 𝓟128{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟127{keys},𝓟124{s},𝓟125{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟128{finalState})).toEqual(𝓛8756{JSON}.stringify(𝓟126{initialState}))
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟128{finalState}.state,𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟128{finalState}.state.aclass,𝓛12643{undefined})).toBeTruthy()
}
𝓟2{it}(𝓛8743{String},𝓟122{$Lambda5})
function 𝓟129{$Lambda6} (): (𝓟130: [miss]𝓛[ty]10033{Void})
{
let 𝓟131{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟132{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟133{initialState}: [miss]𝓛[ty]8642{Object} = {filtered: 𝓟84{t1}};
let 𝓟134{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({filtered: {filter: 𝓛8757{Array}(𝓛8743{String},𝓛8743{String})}});
𝓟259{syncStateUpdate}(𝓟133{initialState},𝓟134{keys},𝓟131{s},𝓟132{skr},𝓛8744{Boolean})
let 𝓟135{raw}: [miss]𝓛[ty]10051{String} = 𝓟131{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟135{raw}).toEqual(𝓛8756{JSON}.stringify(𝓟86{t1Filtered}))
let 𝓟136{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟134{keys},𝓟131{s},𝓟132{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟136{finalState})).toEqual(𝓛8756{JSON}.stringify({filtered: 𝓟86{t1Filtered}}))
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟136{finalState}.filtered,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟129{$Lambda6})
function 𝓟137{$Lambda7} (): (𝓟138: [miss]𝓛[ty]10033{Void})
{
let 𝓟139{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟140{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟141{initialState}: [miss]𝓛[ty]8642{Object} = {replacer: 𝓟84{t1}};
let 𝓟142{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({replacer: {reviver: 𝓟26{replacer}}});
𝓟259{syncStateUpdate}(𝓟141{initialState},𝓟142{keys},𝓟139{s},𝓟140{skr},𝓛8744{Boolean})
let 𝓟143{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟142{keys},𝓟139{s},𝓟140{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟143{finalState})).toEqual(𝓛8756{JSON}.stringify({replacer: 𝓟86{t1Filtered}}))
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟143{finalState}.replacer,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟137{$Lambda7})
function 𝓟144{$Lambda8} (): (𝓟145: [miss]𝓛[ty]10033{Void})
{
let 𝓟146{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟147{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟148{initialState}: [miss]𝓛[ty]8642{Object} = {replacer: 𝓟84{t1}};
let 𝓟149{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({replacer: {replacer: 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}),space: 𝓛8745{Number}}});
𝓟259{syncStateUpdate}(𝓟148{initialState},𝓟149{keys},𝓟146{s},𝓟147{skr},𝓛8744{Boolean})
let 𝓟150{raw}: [miss]𝓛[ty]10051{String} = 𝓟146{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟150{raw}.replace(𝓛8748{RegExp},𝓛8743{String})).toEqual(𝓛8743{String})
let 𝓟151{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟149{keys},𝓟146{s},𝓟147{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟151{finalState})).toEqual(𝓛8743{String})
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟151{finalState}.replacer,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟144{$Lambda8})
function 𝓟152{$Lambda9} (): (𝓟153: [miss]𝓛[ty]10033{Void})
{
let 𝓟154{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟155{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟156{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟157{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({state: {serialize: 𝓟30{serialize},deserialize: 𝓟33{deserialize}}});
𝓟259{syncStateUpdate}(𝓟156{initialState},𝓟157{keys},𝓟154{s},𝓟155{skr},𝓛8744{Boolean})
let 𝓟158{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓟157{keys},𝓟154{s},𝓟155{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟158{finalState})).toEqual(𝓟90{initialStateJson})
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟158{finalState}.state,𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟158{finalState}.state.aclass,𝓛12643{undefined})).toBeTruthy()
}
𝓟2{it}(𝓛8743{String},𝓟152{$Lambda9})
function 𝓟159{$Lambda10} (): (𝓟160: [miss]𝓛[ty]10033{Void})
{
let 𝓟161{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟162{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
𝓟259{syncStateUpdate}(𝓟89{initialState},𝓛8757{Array}(𝓛8743{String}),𝓟161{s},𝓟162{skr},𝓛8744{Boolean})
let 𝓟163{raw}: [miss]𝓛[ty]10051{String} = 𝓟161{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟163{raw}).toEqual(𝓟85{t1Json})
𝓟259{syncStateUpdate}(𝓟91{undefinedState},𝓛8757{Array}(𝓛8743{String}),𝓟161{s},𝓟162{skr},𝓛8744{Boolean})
𝓟163{raw} ⟵ 𝓟161{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟163{raw}).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟159{$Lambda10})
function 𝓟164{$Lambda11} (): (𝓟165: [miss]𝓛[ty]10033{Void})
{
let 𝓟166{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟167{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
𝓟259{syncStateUpdate}(𝓟89{initialState},𝓛8757{Array}(𝓛8743{String}),𝓟166{s},𝓟167{skr},𝓛8744{Boolean})
let 𝓟168{raw}: [miss]𝓛[ty]10051{String} = 𝓟166{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟168{raw}).toEqual(𝓟85{t1Json})
𝓟259{syncStateUpdate}(𝓟91{undefinedState},𝓛8757{Array}(𝓛8743{String}),𝓟166{s},𝓟167{skr},𝓛8744{Boolean})
𝓟168{raw} ⟵ 𝓟166{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟168{raw}).toEqual(𝓟85{t1Json})
}
𝓟2{it}(𝓛8743{String},𝓟164{$Lambda11})
function 𝓟169{$Lambda12} (): (𝓟170: [miss]𝓛[ty]10033{Void})
{
let 𝓟171{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟172{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
const 𝓟173{initalState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟88{t1Simple}};
𝓟259{syncStateUpdate}(𝓟173{initalState},𝓛8757{Array}(𝓛8743{String}),𝓟171{s},𝓟172{skr},𝓛8744{Boolean})
let 𝓟174{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓛8757{Array}(𝓛8743{String}),𝓟171{s},𝓟172{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓟174{finalState}).toEqual(𝓟173{initalState},𝓛8743{String})
}
𝓟2{it}(𝓛8743{String},𝓟169{$Lambda12})
function 𝓟175{$Lambda13} (): (𝓟176: [miss]𝓛[ty]10033{Void})
{
let 𝓟177{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟178{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟179{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟180{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}({state: {encrypt: 𝓟47{encrypt},decrypt: 𝓟51{decrypt}}});
𝓟259{syncStateUpdate}(𝓟179{initialState},𝓟180{keys},𝓟177{s},𝓟178{skr},𝓛8744{Boolean})
let 𝓟181{raw}: [miss]𝓛[ty]10051{String} = 𝓟177{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟51{decrypt}(𝓟181{raw})).toEqual(𝓛8756{JSON}.stringify(𝓟179{initialState}.state))
let 𝓟182{storedState} = 𝓟238{rehydrateApplicationState}(𝓟180{keys},𝓟177{s},𝓟178{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓟90{initialStateJson}).toEqual(𝓛8756{JSON}.stringify(𝓟182{storedState}))
}
𝓟2{it}(𝓛8743{String},𝓟175{$Lambda13})
function 𝓟183{$Lambda14} (): (𝓟184: [miss]𝓛[ty]10033{Void})
{
let 𝓟185{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
let 𝓟186{skr}: [miss]𝓛[ty]8696{Function} = 𝓟79{mockStorageKeySerializer};
let 𝓟187{initialState}: [miss]𝓛[ty]8642{Object} = {state: 𝓟84{t1}};
let 𝓟188{keys};
𝓟188{keys} ⟵ 𝓛8757{Array}({state: {encrypt: 𝓟47{encrypt}}});
𝓟259{syncStateUpdate}(𝓟187{initialState},𝓟188{keys},𝓟185{s},𝓟186{skr},𝓛8744{Boolean})
let 𝓟189{raw}: [miss]𝓛[ty]10051{String} = 𝓟185{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟189{raw}).toEqual(𝓛8756{JSON}.stringify(𝓟187{initialState}.state))
𝓟188{keys} ⟵ 𝓛8757{Array}({state: {decrypt: 𝓟51{decrypt}}});
𝓟259{syncStateUpdate}(𝓟187{initialState},𝓟188{keys},𝓟185{s},𝓟186{skr},𝓛8744{Boolean})
𝓟189{raw} ⟵ 𝓟185{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟189{raw}).toEqual(𝓛8756{JSON}.stringify(𝓟187{initialState}.state))
}
𝓟2{it}(𝓛8743{String},𝓟183{$Lambda14})
function 𝓟190{$Lambda15} (): (𝓟191: [miss]𝓛[ty]10033{Void})
{
let 𝓟192{s}: [miss]𝓟[ty]61{MockStorage} = 𝓟57{CONSTRUCTOR}();
function 𝓟193{$Lambda16} (𝓟194{key}): (𝓟195: [miss]𝓛[ty]10051{String})
{
return 𝓟195 = 𝓛12641{PlusToken}(𝓛8743{String},𝓟194{key})
}
let 𝓟196{skr}: [miss]𝓛[ty]8696{Function} = 𝓟193{$Lambda16};
𝓛1{<UNKNOWN>}(𝓟196{skr}(𝓛8743{String}))
𝓟259{syncStateUpdate}(𝓟89{initialState},𝓛8757{Array}(𝓛8743{String}),𝓟192{s},𝓟196{skr},𝓛8744{Boolean})
let 𝓟197{raw}: [miss]𝓛[ty]10051{String} = 𝓟192{s}.getItem(𝓛8743{String});
𝓟4{expect}(𝓟197{raw}).toBeNull()
let 𝓟198{finalState}: [OOV]any = 𝓟238{rehydrateApplicationState}(𝓛8757{Array}(𝓛8743{String}),𝓟192{s},𝓟196{skr},𝓛8744{Boolean});
𝓟4{expect}(𝓛8756{JSON}.stringify(𝓟198{finalState})).toEqual(𝓟90{initialStateJson})
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟84{t1},𝓛12643{undefined})).toBeTruthy()
𝓟4{expect}(𝓛1{<UNKNOWN>}(𝓟198{finalState}.simple,𝓛12643{undefined})).toBeFalsy()
}
𝓟2{it}(𝓛8743{String},𝓟190{$Lambda15})
}
𝓟3{describe}(𝓛8743{String},𝓟82{$Lambda0})
Module: src/index
type 𝓟[ty]199{LocalStorageConfig} = {storageKeySerializer: (𝓛[ty]10051{String})->𝓛[ty]10051{String}, removeOnUndefined: 𝓛[ty]8666{Boolean}, storage: 𝓛[ty]10926{Storage}, rehydrate: 𝓛[ty]8666{Boolean}, restoreDates: 𝓛[ty]8666{Boolean}, keys: 𝓛[ty]8670{Array}}
const 𝓟200{INIT_ACTION}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟201{UPDATE_ACTION}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟202{detectDate}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
function 𝓟203{$Lambda17} (𝓟204{key}: 𝓛[ty]10051{String},𝓟205{value}: [OOV]any): (𝓟206: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟205{value}),𝓛8743{String}),𝓟202{detectDate}.test(𝓟205{value})))
{
return 𝓟206 = 𝓛8747{Date}.CONSTRUCTOR(𝓟205{value})
}
return 𝓟206 = 𝓟205{value}
}
const 𝓟207{dateReviver}: [miss]𝓛[ty]8696{Function} = 𝓟203{$Lambda17};
function 𝓟208{$Lambda18} (𝓟209{key}: 𝓛[ty]10051{String},𝓟210{value}: [OOV]any): (𝓟211: [OOV]any)
{
return 𝓟211 = 𝓟210{value}
}
const 𝓟212{dummyReviver}: [miss]𝓛[ty]8696{Function} = 𝓟208{$Lambda18};
function 𝓟213{$Lambda19} (𝓟214{keys}: 𝓛[ty]8670{Array}): (𝓟215: [miss]𝓛[ty]8670{Array})
{
function 𝓟216{$Lambda20} (𝓟217{key}): (𝓟218: [OOV]any)
{
let 𝓟219{attr} = 𝓟217{key};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟217{key}),𝓛8743{String}))
{
𝓟219{attr} ⟵ 𝓛8741{Object}.keys(𝓟217{key}).access(𝓛8745{Number});
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟219{attr}),𝓛8743{String}))
{
𝓛8754{TypeError}.CONSTRUCTOR(𝓛12641{PlusToken}(𝓛8743{String},𝓛12607{$Template}(𝓛12580{$TypeOf}(𝓟219{attr}))))
}
return 𝓟218 = 𝓟217{key}
}
return 𝓟215 = 𝓟214{keys}.map(𝓟216{$Lambda20})
}
const 𝓟220{validateStateKeys}: [miss]𝓛[ty]8696{Function} = 𝓟213{$Lambda19};
function 𝓟221{$Lambda21} (𝓟222{keys}: 𝓛[ty]8670{Array},𝓟223{storage}: [OOV]𝓛[ty]10926{Storage},𝓟224{storageKeySerializer}: 𝓛[ty]8696{Function},𝓟225{restoreDates}: 𝓛[ty]8666{Boolean}): (𝓟226: [OOV]any)
{
function 𝓟227{$Lambda22} (𝓟228{acc},𝓟229{curr}): (𝓟230: [OOV]any)
{
let 𝓟231{key} = 𝓟229{curr};
let 𝓟232{reviver}: [miss]𝓛[ty]8696{Function} = (𝓟225{restoreDates} ? 𝓟207{dateReviver} : 𝓟212{dummyReviver};
let 𝓟233{deserialize} = 𝓛12643{undefined};
let 𝓟234{decrypt} = 𝓛12643{undefined};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟231{key}),𝓛8743{String}))
{
𝓟231{key} ⟵ 𝓛8741{Object}.keys(𝓟231{key}).access(𝓛8745{Number});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟229{curr}.access(𝓟231{key})),𝓛8743{String}))
{
𝓟232{reviver} ⟵ 𝓟229{curr}.access(𝓟231{key});
}
else
{
if (𝓟229{curr}.access(𝓟231{key}).reviver)
{
𝓟232{reviver} ⟵ 𝓟229{curr}.access(𝓟231{key}).reviver;
}
if (𝓟229{curr}.access(𝓟231{key}).deserialize)
{
𝓟233{deserialize} ⟵ 𝓟229{curr}.access(𝓟231{key}).deserialize;
}
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟229{curr}.access(𝓟231{key}).encrypt,𝓟229{curr}.access(𝓟231{key}).decrypt))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟229{curr}.access(𝓟231{key}).encrypt),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟229{curr}.access(𝓟231{key}).decrypt),𝓛8743{String})))
{
𝓟234{decrypt} ⟵ 𝓟229{curr}.access(𝓟231{key}).decrypt;
}
else
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟229{curr}.access(𝓟231{key})))
}
}
else
{
if (𝓛12546{BarBarToken}(𝓟229{curr}.access(𝓟231{key}).encrypt,𝓟229{curr}.access(𝓟231{key}).decrypt))
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟229{curr}.access(𝓟231{key})))
}
}
}
let 𝓟235{stateSlice}: [miss]𝓛[ty]10051{String} = 𝓟223{storage}.getItem(𝓟224{storageKeySerializer}(𝓟231{key}));
if (𝓟235{stateSlice})
{
if (𝓟234{decrypt})
{
𝓟235{stateSlice} ⟵ 𝓟234{decrypt}(𝓟235{stateSlice});
}
const 𝓟236{isObjectRegex}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp}.CONSTRUCTOR(𝓛8743{String});
let 𝓟237{raw}: [miss]𝓛[ty]10051{String} = 𝓟235{stateSlice};
if (𝓟236{isObjectRegex}.test(𝓟235{stateSlice}.charAt(𝓛8745{Number})))
{
𝓟237{raw} ⟵ 𝓛8756{JSON}.parse(𝓟235{stateSlice},𝓟232{reviver});
}
return 𝓟230 = 𝓛8741{Object}.assign({},𝓟228{acc},{[key]: (𝓟233{deserialize} ? 𝓟233{deserialize}(𝓟237{raw}) : 𝓟237{raw}})
}
return 𝓟230 = 𝓟228{acc}
}
return 𝓟226 = 𝓟222{keys}.reduce(𝓟227{$Lambda22},{})
}
const 𝓟238{rehydrateApplicationState}: [miss]𝓛[ty]8696{Function} = 𝓟221{$Lambda21};
function 𝓟239{$Lambda23} (𝓟240{state}: [OOV]any,𝓟241{keys}: 𝓛[ty]8670{Array},𝓟242{storage}: [OOV]𝓛[ty]10926{Storage},𝓟243{storageKeySerializer}: 𝓛[ty]8696{Function},𝓟244{removeOnUndefined}: 𝓛[ty]8666{Boolean}): (𝓟245: [miss]𝓛[ty]10033{Void})
{
function 𝓟246{$Lambda24} (𝓟247{key}): (𝓟248: [miss]𝓛[ty]10033{Void})
{
let 𝓟249{stateSlice} = 𝓟240{state}.access(𝓟247{key});
let 𝓟250{replacer} = 𝓛12643{undefined};
let 𝓟251{space} = 𝓛12643{undefined};
let 𝓟252{encrypt} = 𝓛12643{undefined};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟247{key}),𝓛8743{String}))
{
let 𝓟253{name}: [miss]𝓛[ty]10051{String} = 𝓛8741{Object}.keys(𝓟247{key}).access(𝓛8745{Number});
𝓟249{stateSlice} ⟵ 𝓟240{state}.access(𝓟253{name});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟249{stateSlice}),𝓛8743{String}),𝓟247{key}.access(𝓟253{name})))
{
if (𝓟247{key}.access(𝓟253{name}).serialize)
{
𝓟249{stateSlice} ⟵ 𝓟247{key}.access(𝓟253{name}).serialize(𝓟249{stateSlice});
}
else
{
let 𝓟254{filter} = 𝓛12643{undefined};
if (𝓟247{key}.access(𝓟253{name}).reduce)
{
𝓟254{filter} ⟵ 𝓟247{key}.access(𝓟253{name});
}
else
{
if (𝓟247{key}.access(𝓟253{name}).filter)
{
𝓟254{filter} ⟵ 𝓟247{key}.access(𝓟253{name}).filter;
}
}
if (𝓟254{filter})
{
function 𝓟255{$Lambda25} (𝓟256{memo},𝓟257{attr}): (𝓟258: [OOV]any)
{
𝓟256{memo}.access(𝓟257{attr}) ⟵ 𝓟249{stateSlice}.access(𝓟257{attr});
return 𝓟258 = 𝓟256{memo}
}
𝓟249{stateSlice} ⟵ 𝓟254{filter}.reduce(𝓟255{$Lambda25},{});
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟247{key}.access(𝓟253{name}).encrypt,𝓟247{key}.access(𝓟253{name}).decrypt))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟247{key}.access(𝓟253{name}).encrypt),𝓛8743{String}))
{
𝓟252{encrypt} ⟵ 𝓟247{key}.access(𝓟253{name}).encrypt;
}
}
else
{
if (𝓛12546{BarBarToken}(𝓟247{key}.access(𝓟253{name}).encrypt,𝓟247{key}.access(𝓟253{name}).decrypt))
{
𝓛1{<UNKNOWN>}(𝓛12607{$Template}(𝓟247{key}.access(𝓟253{name})))
}
}
}
𝓟250{replacer} ⟵ 𝓟247{key}.access(𝓟253{name}).replacer;
𝓟251{space} ⟵ 𝓟247{key}.access(𝓟253{name}).space;
}
𝓟247{key} ⟵ 𝓟253{name};
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟249{stateSlice}),𝓛8743{String}))
{
{
if (𝓟252{encrypt})
{
𝓟249{stateSlice} ⟵ 𝓟252{encrypt}((𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟249{stateSlice}),𝓛8743{String}) ? 𝓟249{stateSlice} : 𝓛8756{JSON}.stringify(𝓟249{stateSlice},𝓟250{replacer},𝓟251{space}));
}
𝓟242{storage}.setItem(𝓟243{storageKeySerializer}(𝓟247{key}),(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟249{stateSlice}),𝓛8743{String}) ? 𝓟249{stateSlice} : 𝓛8756{JSON}.stringify(𝓟249{stateSlice},𝓟250{replacer},𝓟251{space})))
}
}
else
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟249{stateSlice}),𝓛8743{String}),𝓟244{removeOnUndefined}))
{
{
𝓟242{storage}.removeItem(𝓟243{storageKeySerializer}(𝓟247{key}))
}
}
}
}
𝓟241{keys}.forEach(𝓟246{$Lambda24})
}
const 𝓟259{syncStateUpdate}: [miss]𝓛[ty]8696{Function} = 𝓟239{$Lambda23};
function 𝓟260{$Lambda26} (𝓟261{config}: [OOV]𝓟[ty]199{LocalStorageConfig}): (𝓟262: [miss]𝓛[ty]8696{Function})
{
function 𝓟263{$Lambda27} (𝓟264{reducer}: [OOV]any): (𝓟265: [miss]𝓛[ty]8696{Function})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟261{config}.storage,𝓛12643{undefined}))
{
𝓟261{config}.storage ⟵ 𝓛12546{BarBarToken}(𝓛12496{localStorage},𝓛12233{window}.localStorage);
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟261{config}.storageKeySerializer,𝓛12643{undefined}))
{
function 𝓟266{$Lambda28} (𝓟267{key}): (𝓟268: [miss]𝓛[ty]10051{String})
{
return 𝓟268 = 𝓟267{key}
}
𝓟261{config}.storageKeySerializer ⟵ 𝓟266{$Lambda28};
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟261{config}.restoreDates,𝓛12643{undefined}))
{
𝓟261{config}.restoreDates ⟵ 𝓛8744{Boolean};
}
const 𝓟269{stateKeys}: [miss]𝓛[ty]8670{Array} = 𝓟220{validateStateKeys}(𝓟261{config}.keys);
const 𝓟270{rehydratedState} = (𝓟261{config}.rehydrate ? 𝓟238{rehydrateApplicationState}(𝓟269{stateKeys},𝓟261{config}.storage,𝓟261{config}.storageKeySerializer,𝓟261{config}.restoreDates) : 𝓛12643{undefined};
function 𝓟271{$Lambda29} (𝓟272{state},𝓟273{action}: [OOV]any): (𝓟274: [OOV]any)
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟273{action}.type,𝓟200{INIT_ACTION}),𝓛12559{EqualsEqualsEqualsToken}(𝓟273{action}.type,𝓟201{UPDATE_ACTION})),𝓟270{rehydratedState}))
{
𝓟272{state} ⟵ 𝓛8741{Object}.assign({},𝓟272{state},𝓟270{rehydratedState});
}
const 𝓟275{nextState} = 𝓟264{reducer}(𝓟272{state},𝓟273{action});
𝓟259{syncStateUpdate}(𝓟275{nextState},𝓟269{stateKeys},𝓟261{config}.storage,𝓟261{config}.storageKeySerializer,𝓟261{config}.removeOnUndefined)
return 𝓟274 = 𝓟275{nextState}
}
return 𝓟265 = 𝓟271{$Lambda29}
}
return 𝓟262 = 𝓟263{$Lambda27}
}
const 𝓟276{localStorageSync}: [miss]𝓛[ty]8696{Function} = 𝓟260{$Lambda26};
function 𝓟277{$Lambda30} (𝓟278{keys}: 𝓛[ty]8670{Array},𝓟279{rehydrate}: 𝓛[ty]8666{Boolean},𝓟280{removeOnUndefined}: 𝓛[ty]8666{Boolean}): (𝓟281: [miss]𝓛[ty]8696{Function})
{
function 𝓟282{$Lambda31} (𝓟283{reducer}: [OOV]any): (𝓟284: [OOV]any)
{
let 𝓟285{config}: [OOV]𝓟[ty]199{LocalStorageConfig} = {keys: 𝓟278{keys},rehydrate: 𝓟279{rehydrate},storage: 𝓛12496{localStorage},removeOnUndefined: 𝓟280{removeOnUndefined}};
return 𝓟284 = 𝓛12552{this}.localStorageSync(𝓟285{config})
}
return 𝓟281 = 𝓟282{$Lambda31}
}
const 𝓟286{localStorageSyncAndClean}: [miss]𝓛[ty]8696{Function} = 𝓟277{$Lambda30};