Hey Mario. The problem here is that the parent is assuming that the child is still working on preparing a response. By default, it waits indefinitely, but you can configure a timeout when the connectToChild is called (see https://github.com/Aaronius/penpal#options). Once you configure a timeout, if the parent doesn't hear a response from the child after the timeout passes, your .catch should be hit.

There may be a better way to handle this in Penpal so that you don't have to wait for the timeout to pass in this particular case. Maybe Penpal could detect when the iframe is navigated from one page to another and if there's no attempt from the child to reconnect it could immediately fail method calls from the parent. Something like that. I need to think about this some more.

Sorry, I misspoke. The timeout configuration option only applies to waiting for the initial connection to be established, so it won't work for your specific situation.

@mariovde, would your ideal solution be that Penpal provides an event that notifies you when there's a disconnection and then a separate event that notifies you when there's a re-connection?

@Aaronius Well, okay, that's why we were waiting so long to see the timeout kick in :)... it never came.
Yes, I think it would be good for everyone to know when the connection was lost and when it would reconnect.
That would be awesome for sure!

Okay, thank you. Providing an event for reconnection will be probably simple enough. Providing an event for "disconnection" might be trickier, but I'll play around with some ideas. Thanks for bringing this up.

@mariovde I'm curious to know what you'd like this API to look like. I've got some ideas, but I don't really love them.

@Aaronius how about adding another config option onConnectionLost : function() ?

const connection = connectToChild({
// The iframe to which a connection should be made
iframe,
// Methods the parent is exposing to the child
methods: {
add(num1, num2) {
return num1 + num2;
},
},
onConnectionLost: function(params);
onConnection: function(params);
});

something like that?

That's where I was headed. It prompts a few questions:

• Does onConnection get called on the initial connection and all subsequent connections, or just the subsequent connections?
• What are the params to onConnection. Maybe the child object?
• Should the child object provided through connection.promise stop functioning after a reconnection? Its API may be different than the newly-connected child API.
• If onConnection is called on the initial connection and all subsequent connections, does that make onConnection redundant to connection.promise and should we therefore remove connection.promise?

I'm thinking it might be more appropriate to have onDisconnect (assuming this functionality is feasible) and onReconnect, where onReconnect only gets called on subsequent connections. On a reconnect, a new child object would get passed to the onReconnect callback and the child object provided through connection.promise would stop functioning (an error would be thrown if the parent attempts to call its methods).

I'm not in love with it though.

Love PenPal! 🔥

I haven't dug in enough to respond completely coherently so excuse misunderstanding.

I like the idea of isStillConnectedToChild.

Rather than PenPal providing a loss of connection to the child, and then a reconnection to the child, it only confirms it "is Still Connected" connected to the child.

Idea

isStillConnectedToChild() // => boolean
// is still connected to the child (?)
// then do stuff

Thanks for the feedback @yowainwright!

just thinking out loud, would it make sense to have a heartbeat between parent and child ? If not received, we can assume they are disconnected. still thinking for better solutions.

We really like penpal. We'd appreciate a "connection lost" feature.
I think what @mariovde suggested is good, but maybe you can add the same thing to the connectToParent.

const connection = connectToChild({
// The iframe to which a connection should be made
iframe,
// Methods the parent is exposing to the child
methods: {
add(num1, num2) {
return num1 + num2;
},
},
onConnectionLost: function(params);
onConnection: function(params);
});

const connection = connectToParent({
methods: {
add(num1, num2) {
return num1 + num2;
},
},
onConnectionLost: function(params);
onConnection: function(params);
});

Hey folks, @Kohart wrote up a PR (thank you!) for addressing this issue, but before proceeding with the PR I want to make sure we have a clear and reasonable definition of "connection lost". Here are some example scenarios that may or may not be considered as "connection lost":

• When the iframe is removed?
• When the iframe is navigated away from its current document?
• When a method call doesn't receive a response within a particular time period?
• When a heartbeat (which doesn't exist yet) fails?
• When connection.destroy() is called?

To answer this, I think it would be useful to understand how you would plan to use an onConnectionLost feature it in your applications. In other words, if you were notified that the connection was lost, what action would you take within your application?