umd | Universal Module Definition ) patterns for JavaScript modules | User Interface library

It is because react in strict mode can invoke render function multiple times before committing to DOM (similarly to react behavior in react 18 - one render doesn't mean commit). If you remove StrictMode from your app root you will see Value: two in the screen. More info is at: https://reactjs.org/docs/strict-mode.html#detecting-unexpected-side-effects

These descriptions are outdated. It used to be the case that the type R of real numbers was axiomatized, along with its basic properties. But nowadays (since 2019?) it is defined in terms of more basic axioms, more or less like one would do in traditional mathematics.

According to Bootstrap 5 (Separate section), Bootstrap 5 requires @popperjs/core but not popperjs. Hence you were installing and importing wrong library.

FYI, Bootstrap 5 removed dependency on jQuery.

1. Install @popperjs/core via npm

You should run the dist version of your app. Meaning, you should use a bundler like webpack. Unbundled (pure) code can't use these features.

Don’t talk about caches when it comes to Java’s memory model. What matters, are formal happens-before relationships.

Note that computeValue() is declared synchronized, so for threads executing the method, reorderings within the method are irrelevant, as they can only enter the method when any thread which executed the method before, has exited the method and there is a happens-before relationship between the method exit of the previous threads and the next thread entering the method.

The really interesting method is

You can find a working example of what you're going for here. I'll go through some of the changes that needed to be made to your code one-by-one in this reply.

Can't resolve 'obsidian' in 'path\kotlin' occurs because the obsidian-api package is not a standalone library. Instead, it only consist of a obsidian.d.ts file, which is a TypeScript declaration file. Similar to a header file in other languages, this header file does not provide any implementations, but only the signatures and types for the library – meaning Kotlin/JS' webpack (or any JavaScript tooling, for that matter) won't be able to resolve the actual implementations. This is expected, and can be addressed by declaring the module as external. To do so in Kotlin/JS, create a directory called webpack.config.d, and add a file 01.externals.js with the following content:

The main issue seems to be that you placed your "Main content" in one single row.
I managed to make it work doing something similar to this.

Also I moved the header and footer placeholders to thead and tfoot respectively.
Additionally, the "@page{margin: 5cm;}" seems to break it, to be honest I don't know why.
I had to modify the code quite a bit but I hope it helps you as a template for what you want to achieve.

This is the code I ended up with:

Normally useEffect and its cleanup are called asynchronously (on another stack) after render. But if you call setState in a timer and there are useEffect callbacks, they are invoked eagerly but all accumulated state change from cleanup is called after setState that invoked this operation.

So in your example when setTimeout handler is called:

• when calling setA: a state is changed and two state changes from cleanup are added to pending state change queue
• when calling setB: first valueB is applied to b and then null from the cleanup (it's kind of batched here)

This tries to imitate the behaviour when state updates are actually batched like in click handlers (first apply state updates from the click handler and then from useEffect).

You can see what's happening more clearly when you use updater functions:

From the Github issue, find this comment

This is a known quirk due to the implementation details of concurrency in React. We don't cheaply know which of two versions is currently committed. When this ambiguity happens we have to over render once and after that we know that both versions are the same and it doesn't matter.

So we cannot help the component in question BUT we can help the children from not getting affected.

How?

Use React.memo.

The component children would therefore not get affected by the second, useless re-render.