How to use the belter/src.uniqueID function in belter

// $FlowFixMe
                targetWindow = options.window.contentWindow;
            }
        } else {
            targetWindow = options.window;
        }

        if (!targetWindow) {
            throw new Error('Expected options.window to be a window object, iframe, or iframe element id.');
        }

        var win = targetWindow;

        domain = options.domain || WILDCARD;

        var hash = options.name + '_' + uniqueID();

        if (isWindowClosed(win)) {
            throw new Error('Target window is closed');
        }

        var hasResult = false;

        var reqPromises = requestPromises.getOrSet(win, function () {
            return [];
        });

        var requestPromise = ZalgoPromise['try'](function () {

            if (isAncestor(window, win)) {
                return awaitWindowHello(win, options.timeout || CONFIG.CHILD_WINDOW_TIMEOUT);
            }

const onApprove = () => {
        if (!props) {
            throw new Error(`Can not approve without getting props`);
        }

        onApproveRequestID = uniqueID();

        send(JSON.stringify({
            session_uid:        getSessionUID(),
            source_app:         'paypal_native_checkout_sdk',
            source_app_version: '1.2.3',
            target_app:         'paypal_smart_payment_buttons',
            request_uid:        onApproveRequestID,
            message_uid:        uniqueID(),
            message_type:       'request',
            message_name:       'onApprove',
            message_data:       {
                orderID: props.orderID,
                payerID: 'XXYYZZ123456'
            }
        }));
    };

return this.tryInit(() => {
            this.component.log(`render`);

            let uid = uniqueID();
            let tasks = {};
            
            tasks.onRender = this.props.onRender();

            let domain = this.getDomain();
            let initialDomain = this.getInitialDomain();

            tasks.elementReady = ZalgoPromise.try(() => {
                if (element) {
                    return this.elementReady(element);
                }
            });

            let focus = () => {
                return tasks.open.then(proxyWin => proxyWin.focus());
            };

function getSerializedWindow(winPromise : ZalgoPromise, { send, id = uniqueID() } : { send : SendType, id? : string }) : SerializedWindowType {
    
    let windowNamePromise = winPromise.then(win => {
        if (isSameDomain(win)) {
            return assertSameDomain(win).name;
        }
    });
    
    return {
        id,
        getType: () => winPromise.then(win => {
            return getOpener(win) ? WINDOW_TYPE.POPUP : WINDOW_TYPE.IFRAME;
        }),
        getInstanceID: memoizePromise(() => winPromise.then(win => getWindowInstanceID(win, { send }))),
        close:         () => winPromise.then(closeWindow),
        getName:       () => winPromise.then(win => {
            if (isWindowClosed(win)) {

return ZalgoPromise.try(() => {
        const { version, firebase: firebaseConfig } = config;
        const { getPageUrl } = props;

        sessionUID = uniqueID();
        nativeSocket = getNativeSocket({
            sessionUID, firebaseConfig, version
        });

        nativeSocket.onError(err => {
            nativeSocket = null;
            getLogger().error('native_socket_error', { err: stringifyError(err) });
        });

        return getPageUrl().then(pageUrl => {
            initialPageUrl = pageUrl;
        });
    });
}

function addTunnelWindow({ name, source, canary, sendMessage } : TunnelWindowDataType) : string {
    cleanTunnelWindows();
    const id = uniqueID();
    const tunnelWindows = globalStore('tunnelWindows');
    tunnelWindows.set(id, { name, source, canary, sendMessage });
    return id;
}

export function sendMessage(win : CrossDomainWindowType, domain : DomainMatcher, message : Message, { on, send } : { on : OnType, send : SendType }) {
    if (isWindowClosed(win)) {
        throw new Error('Window is closed');
    }
    
    const serializedMessage = serializeMessage(win, domain, {
        [ __POST_ROBOT__.__GLOBAL_KEY__ ]: {
            id:     uniqueID(),
            origin: getDomain(window),
            ...message
        }
    }, { on, send });

    const strategies = Object.keys(SEND_MESSAGE_STRATEGIES);
    const errors = [];

    for (const strategyName of strategies) {
        try {
            SEND_MESSAGE_STRATEGIES[strategyName](win, serializedMessage, domain);
        } catch (err) {
            errors.push(err);
        }
    }

const sendMessage = (socket, data) => {
        const messageUID = uniqueID();
        receivedMessages[messageUID] = true;

        const message = {
            session_uid:        sessionUID,
            message_uid:        messageUID,
            source_app:         sourceApp,
            source_app_version: sourceAppVersion,
            target_app:         targetApp,
            ...data
        };

        socket.send(JSON.stringify(message));
    };