weatherData | simple R package that fetches Weather data | Data Visualization library

useQuery - got triggered on render. Retriggered on params change. Returns data from cache if the cache has some valid data. refetch allows to ignore cache, and forces to make a real API call. refetch has no query params, so you'll need to pass them to initial hook call.

useLazyQuery - got triggered firstly on trigger call, expecting the query params to be passed to trigger, and by default will do a real API call. To get the cached data first (if exists) - you'll need to pass the preferCacheValue param to the trigger function as the second param.

So the "rule of thumb" will be to use useQuery by default to fetch data on the component mount, use refetch when you want to make a real API call ignoring the cache.

useLazyQuery - for cases like yours, when you want to make a call only later (ignoring the render stage) calling the "trigger" on some event (like a button click), and remember about the preferCacheValue option for a case when you have a chance to have the response already cached - this will allow making response feels instantaneous.

In our case - useLazyQuery is MUCH relevant, due to you can avoid all that setCurrentPosition => dispatch => useSelector stuff, and pull all that logic just in click handler, where you'll be able to fetch Geolocation.getCurrentPosition() and pass coordinates to trigger function, that where relevant to the click time, not to the time when the component was rendered.

The img tag loads all the images fine for the first call however, the problem is that when I do another zipcode and clicked search, the texts updated, but the img tag (the weather images) did not update ( i.e. first search 91001 everything looks great, searched again for 95133, name changed to San Jose but the weather forecast images did not update from 91001's to 95133's)

You always append forecast data to the forecast state but only reference the first 8 elements.

Most importantly, in your current code, you create a new ListView when you've gotten the weather back when you do this:

• Interfaces represent contracts. In Java, the contract is mainly about a set of methods. In UML, it can be broader, e.g. be about operations (methods), properties (fields), associations (not a java language feature: there are several ways to implement them), or contraints (preconditions, postconditions, invariants, ...).
• Classes have to fulfil the contracts of the interfaces that they realize/implement. In Java, the compiler will only verify that the class implements the methods required by the interface and with the right signature. The developper would nevertheles expect more, i.e. that the java class behaves according to the interface's documentation. In UML, you'd similarly expect that a class provides itself all the features promised by the interface (see here).
• How are the rules be enforced? In Java, you'll have to be explicit: all methods must be provided or you'll get a compilation error. If you'd use TDD, you'd also foresee a set of tests that verifies that an object behaves according to contract of the interface. In UML, you can have ambiguities, because you are not forced to show everything in a diagram. So if you don't show a class feature or an association, it doesn't meant that there is not such thing: the thing could be in the model but not shown in a particular diagram. So if a class implements an interface, you could assume that it provides the elements even if they are not shown in the diagram. If you'd use such an ambiguous diagram for code generation, the code would not compile.

Coming back to your observer:

• the diagram tells us that the Subject has a navigable association to Observer. In the code, you cannot implement nor even directly declare this kind of relationship in the interface. However, the fact that the Subject interface shall allow to register and remove Observers, implicitly suggest such an association.
• the diagram don't tell us that WheatherData has a navigable association to CurrentConditionDisplay. But in principle, they should, since these classes realize Subject and Observer respectively. This makes the diagram ambiguous. However, if we trust these classes to comply with the interface, we could live without showing the extra associations, just assuming that they have to be here. Moreover, strict UML compliance would require to add 3 such associations here, making the diagram more difficult to read.

Now, as you rightly say, we could implement the design patterns using an abstract class instead of an interface. But since Java does not allow multiple inheritance, this approach would forbid subjects or observers to be in other class hierarchies.

First of all, the observer pattern -- as all patterns in Heads first Design Pattern -- originates from the GoF. Interestingly, GoF predates UML and Java; Its patterns only used class inheritance, if needed with multiple inheritance. When the book mentioned "interface", it was only about the implicit interface exposed by classes, very often abstract classes.

When Java came out, it was then a challenge to transpose all these design patterns, making explicit difference between interfaces (in the Java sense) and abstract classes. This is why you'll often find several variants among class diagrams of these patterns.

Heads first is no exception. The goal of that excellent book is to teach using patterns in coding. The main purpose of its diagrams is therefore to convey the design intent, and not to teach the rigorous use of advanced UML. So they used diagrams that might sometimes be formally ambiguous. Overall I think they made an excellent job.

I noticed in Firefox the issue was being caused as it was receiving an 400 error from my API fetch request. This was not the case in Chrome and Edge. Therefore, In the end I modified my fetch so that with the response I could see if I was getting any errors. If it does get any errors, all I do is simply clear out the entire localStorage and set apiFailed to true, which in turn runs the block of code to display the error page and message.

Here is the if statement within my fetch:

You also need to handle failed weather requests.

Form - When the TextField is interacted with you should reset the click state.