Iframe Message Proxy

This package is used for BLiP platform to handle communications between micro frontends, done by iframes throught postMessages. Basically, we send a message and wait for response. It is possible because every message sended to parent window throught IframeMessageProxy has a cached promise with an ID that is resolved when current window receive a message with the same ID. Jump to Usage section to more details.

Installation

npm i -S iframe-message-proxy

Usage

import { IframeMessageProxy } from 'iframe-message-proxy';

IframeMessageProxy.listen(); // Start listen for post messages

// Sending messages
IframeMessageProxy.sendMessage({
  action: 'customAction',
  content: 'Here is my awesome action',
});

sendMessage method takes an object as param that accept these properties:

Property	Type	Required	Description
action	string	true	Action sended to parent iframe. By default, is prefixed by blipEvent:
content	any	false	Actions can have optional contents added
fireAndForget	boolean	false	Messages can have no response and be just a command to parent iframe
caller	string	false	Every message has a caller. By default, is used child iframe name (passed as attribute on <iframe name="iframe-name">...) but you can set a custom caller name too.

By default, sendMessage method will send a postMessage to parent window and wait for some response, if has one.

// Child iframe
const action = await IframeMessageProxy.sendMessage({
  action: 'customAction',
  content: 'Here is my awesome action',
});

// Parent iframe
const iframe = document.getElementById('my-iframe').contentWindow; // Get iframe caller

// Handle received messages
const handleOnReceiveMessage = msgEvt: MessageEvent => {
  /**
   * Assuming that window can receive many postMessage events,
   * there is a tip to filter only messages camed from our library
   */
  const BLIP_EVENT_PREFIX = 'blipEvent:'
  const shouldHandleMessage = msg =>
    Object.keys(msg)
      .find(k => k == 'action' && msg.action.startsWith(BLIP_EVENT_PREFIX));

  if (!msgEvt.data || !message || !shouldHandleMessage(msgEvt.data.message)) {
    return;
  }

  /**
   * Every message has properties "message" and "trackingProperties".
   * "trackingProperties" is used by Iframe Message Proxy to identify
   * which promise will be resolved after send a postMessage, so
   * if you want to send something back to caller, you have to pass
   * trackingProperties received from child iframe.
   */
  const { message, trackingProperties } = msgEvt.data;

  iframe.postMessage({
    response: 'Success!',
    trackingProperties
  }, '*')
}

window.addEventListener('message', handleOnReceiveMessage);

Handling errors

If you want to send an error message to child iframe, you may also add error property to response object. In this way, the child iframe will reject the promise instead of resolve them.

try {
  doSomethingWrong();
} catch (e) {
  iframe.postMessage({
    error: e.toString(),
    trackingProperties
  }, '*')
}

Configuring

You can also configure defaults by config method:

IframeMessageProxy.config({
  prefix: 'customPrefix:',
  eventCaller: 'jarvis',
})

prefix?: string caller?: string receiveWindow?: Window targetWindow?: Window shouldHandleMessage?: ((message: IIdentifiedMessage) => boolean)

Property	Type	Default	Description
prefix	string	blipEvent:	Action prefix
caller	string	window.name	Caller name
receiveWindow	Window	window	Window that will receive postMessages responses
targetWindow	Window	window.parent	Window that we'll request something
shouldHandleMessage	() => boolean	undefined	You can choose what message will be parsed or not by calling a function that takes a MessageEvent as argument. function(evt) { if (!evt.data) return false }