Add API to block the initial "transition" about history

[mjackson]

Transition hooks were never intended to be called on the initial create. For example, if you return false to cancel the initial transition, where does that leave us?

Think of transition hooks like the componentWillUpdate React component lifecycle method.

[aldendaniels]

Transition hooks were never intended to be called on the initial create.

Yes, but I'm suggesting that doing so now would be a good idea. 😄

For example, if you return false to cancel the initial transition, where does that leave us?

Abort (never call listeners) and log an error or warning to the console.

This feature is a must have if we want to allow users to use transition hooks to block transitions during async data loading. I've tried to make the case for why I think this is important. I'm guessing, however, that we still aren't on one page about whether or not the use-case is legitimate. Until we agree on the use-case, we're not going to get very far with the implementation discussion.

[mjackson]

This feature is a must have if we want to allow users to use transition hooks to block transitions during async data loading

I don't agree. You already have an API to block transitions. What you're looking for is a way to block the initial "transition" while you load data, which you could easily do with a history enhancer:

function useDataLoader(createHistory) {
  return function (options={}) {
    let { dataLoader, ...historyOptions } = options
    let history = createHistory(historyOptions)

    let prevLocation = null

    function listen(listener) {
      return history.listen(function (location) {
        if (prevLocation == null) {
          // Block the initial transition and load some data.
          // loadData is an API that asynchronously loads some
          // data for a given location.
          dataLoader.loadData(location, function () {
            // getData is a synchronous method that gets previously
            // loaded data from a client-side cache.
            listener(location, dataLoader.getData(location))
          })
        } else {
          // Data was already loaded in the listenBefore callback.
          listener(location, dataLoader.getData(location))
        }

        // Hang onto the previous location to know if
        // we're in the initial listen callback or not.
        prevLocation = location
      })
    }

    // Use a listenBefore hook to block subsequent
    // transitions while we load data.
    history.listenBefore(function (location, callback) {
      dataLoader.loadData(location, callback)
    })

    return {
      ...history,
      listen
    }
  }
}

This isn't really that complex, and it means that we don't have to make assumptions in the history package about how people want to do their data loading.

[mjackson]

Closing this, as the conversation has stalled. Hopefully the code I posted above helps.