textiot/react-native-sdk/dist/events.js

A framework for building web and native (IoT) Dapps on the IPFS network

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.addSyncFailedListener = exports.addSyncCompleteListener = exports.addSyncUpdateListener = exports.addContactQueryResultListener = exports.addClientThreadQueryResultListener = exports.addPubsubQueryResultListener = exports.addQueryErrorListener = exports.addQueryDoneListener = exports.addAccountPeerRemovedListener = exports.addAccountPeerAddedListener = exports.addThreadRemovedListener = exports.addThreadAddedListener = exports.addThreadUpdateReceivedListener = exports.addNotificationReceivedListener = exports.addCanceledPendingNodeStopListener = exports.addWillStopNodeInBackgroundAfterDelayListener = exports.addNodeOnlineListener = exports.addNodeFailedToStopListener = exports.addNodeStoppedListener = exports.addNodeFailedToStartListener = exports.addNodeStartedListener = void 0;
const react_native_1 = require("react-native");
const buffer_1 = require("buffer");
const model_1 = require("./model");
const util_internal_1 = require("./util-internal");
const { TextileEvents } = react_native_1.NativeModules;
const eventEmitter = react_native_1.Platform.select({
    android: react_native_1.DeviceEventEmitter,
    ios: new react_native_1.NativeEventEmitter(TextileEvents)
});
let nodeStartedListeners = [];
let nodeFailedToStartListeners = [];
let nodeStoppedListeners = [];
let nodeFailedToStopListeners = [];
let nodeOnlineListeners = [];
let willStopNodeInBackgroundAfterDelayListeners = [];
let canceledPendingNodeStopListeners = [];
let notificationReceivedListeners = [];
let threadUpdateReceivedListeners = [];
let threadAddedListeners = [];
let threadRemovedListeners = [];
let accountPeerAddedListeners = [];
let accountPeerRemovedListeners = [];
let queryDoneListeners = [];
let queryErrorListeners = [];
let pubsubQueryResultListeners = [];
let clientThreadQueryResultListeners = [];
let contactQueryResultListeners = [];
let syncUpdateListeners = [];
let syncCompleteListeners = [];
let syncFailedListeners = [];
function addNodeStartedListener(listener) {
    nodeStartedListeners.push(listener);
    return new model_1.EventSubscription(() => (nodeStartedListeners = nodeStartedListeners.filter(item => item !== listener)));
}
exports.addNodeStartedListener = addNodeStartedListener;
function addNodeFailedToStartListener(listener) {
    nodeFailedToStartListeners.push(listener);
    return new model_1.EventSubscription(() => (nodeFailedToStartListeners = nodeFailedToStartListeners.filter(item => item !== listener)));
}
exports.addNodeFailedToStartListener = addNodeFailedToStartListener;
function addNodeStoppedListener(listener) {
    nodeStoppedListeners.push(listener);
    return new model_1.EventSubscription(() => (nodeStoppedListeners = nodeStoppedListeners.filter(item => item !== listener)));
}
exports.addNodeStoppedListener = addNodeStoppedListener;
function addNodeFailedToStopListener(listener) {
    nodeFailedToStopListeners.push(listener);
    return new model_1.EventSubscription(() => (nodeFailedToStopListeners = nodeFailedToStopListeners.filter(item => item !== listener)));
}
exports.addNodeFailedToStopListener = addNodeFailedToStopListener;
function addNodeOnlineListener(listener) {
    nodeOnlineListeners.push(listener);
    return new model_1.EventSubscription(() => (nodeOnlineListeners = nodeOnlineListeners.filter(item => item !== listener)));
}
exports.addNodeOnlineListener = addNodeOnlineListener;
// tslint:disable-next-line:max-line-length
function addWillStopNodeInBackgroundAfterDelayListener(listener) {
    willStopNodeInBackgroundAfterDelayListeners.push(listener);
    return new model_1.EventSubscription(
    // tslint:disable-next-line:max-line-length
    () => (willStopNodeInBackgroundAfterDelayListeners = willStopNodeInBackgroundAfterDelayListeners.filter(item => item !== listener)));
}
exports.addWillStopNodeInBackgroundAfterDelayListener = addWillStopNodeInBackgroundAfterDelayListener;
function addCanceledPendingNodeStopListener(listener) {
    canceledPendingNodeStopListeners.push(listener);
    return new model_1.EventSubscription(() => (canceledPendingNodeStopListeners = canceledPendingNodeStopListeners.filter(item => item !== listener)));
}
exports.addCanceledPendingNodeStopListener = addCanceledPendingNodeStopListener;
// tslint:disable-next-line:max-line-length
function addNotificationReceivedListener(listener) {
    notificationReceivedListeners.push(listener);
    return new model_1.EventSubscription(() => (notificationReceivedListeners = notificationReceivedListeners.filter(item => item !== listener)));
}
exports.addNotificationReceivedListener = addNotificationReceivedListener;
function addThreadUpdateReceivedListener(listener) {
    threadUpdateReceivedListeners.push(listener);
    return new model_1.EventSubscription(() => (threadUpdateReceivedListeners = threadUpdateReceivedListeners.filter(item => item !== listener)));
}
exports.addThreadUpdateReceivedListener = addThreadUpdateReceivedListener;
function addThreadAddedListener(listener) {
    threadAddedListeners.push(listener);
    return new model_1.EventSubscription(() => (threadAddedListeners = threadAddedListeners.filter(item => item !== listener)));
}
exports.addThreadAddedListener = addThreadAddedListener;
function addThreadRemovedListener(listener) {
    threadRemovedListeners.push(listener);
    return new model_1.EventSubscription(() => (threadRemovedListeners = threadRemovedListeners.filter(item => item !== listener)));
}
exports.addThreadRemovedListener = addThreadRemovedListener;
function addAccountPeerAddedListener(listener) {
    accountPeerAddedListeners.push(listener);
    return new model_1.EventSubscription(() => (accountPeerAddedListeners = accountPeerAddedListeners.filter(item => item !== listener)));
}
exports.addAccountPeerAddedListener = addAccountPeerAddedListener;
function addAccountPeerRemovedListener(listener) {
    accountPeerRemovedListeners.push(listener);
    return new model_1.EventSubscription(() => (accountPeerRemovedListeners = accountPeerRemovedListeners.filter(item => item !== listener)));
}
exports.addAccountPeerRemovedListener = addAccountPeerRemovedListener;
function addQueryDoneListener(listener, queryId) {
    queryDoneListeners.push(queryId
        ? {
            listener,
            queryId
        }
        : listener);
    return new model_1.EventSubscription(() => (queryDoneListeners = queryDoneListeners.filter(item => item.queryId ? item.queryId !== queryId : item !== listener)));
}
exports.addQueryDoneListener = addQueryDoneListener;
function addQueryErrorListener(listener, queryId) {
    queryErrorListeners.push(queryId
        ? {
            listener,
            queryId
        }
        : listener);
    return new model_1.EventSubscription(() => (queryErrorListeners = queryErrorListeners.filter(item => item.queryId ? item.queryId !== queryId : item !== listener)));
}
exports.addQueryErrorListener = addQueryErrorListener;
function addPubsubQueryResultListener(listener, queryId, queryHandle) {
    pubsubQueryResultListeners.push({
        listener,
        queryId
    });
    return new model_1.EventSubscription(() => {
        pubsubQueryResultListeners = pubsubQueryResultListeners.filter(item => item.queryId !== queryId);
        queryDoneListeners = queryDoneListeners.filter(item => item.queryId !== queryId);
        queryErrorListeners = queryErrorListeners.filter(item => item.queryId !== queryId);
        queryHandle.close();
    });
}
exports.addPubsubQueryResultListener = addPubsubQueryResultListener;
function addClientThreadQueryResultListener(listener) {
    clientThreadQueryResultListeners.push(listener);
    return new model_1.EventSubscription(() => (clientThreadQueryResultListeners = clientThreadQueryResultListeners.filter(item => item !== listener)));
}
exports.addClientThreadQueryResultListener = addClientThreadQueryResultListener;
function addContactQueryResultListener(listener) {
    contactQueryResultListeners.push(listener);
    return new model_1.EventSubscription(() => (contactQueryResultListeners = contactQueryResultListeners.filter(item => item !== listener)));
}
exports.addContactQueryResultListener = addContactQueryResultListener;
function addSyncUpdateListener(listener) {
    syncUpdateListeners.push(listener);
    return new model_1.EventSubscription(() => (syncUpdateListeners = syncUpdateListeners.filter(item => item !== listener)));
}
exports.addSyncUpdateListener = addSyncUpdateListener;
function addSyncCompleteListener(listener) {
    syncCompleteListeners.push(listener);
    return new model_1.EventSubscription(() => (syncCompleteListeners = syncCompleteListeners.filter(item => item !== listener)));
}
exports.addSyncCompleteListener = addSyncCompleteListener;
function addSyncFailedListener(listener) {
    syncFailedListeners.push(listener);
    return new model_1.EventSubscription(() => (syncFailedListeners = syncFailedListeners.filter(item => item !== listener)));
}
exports.addSyncFailedListener = addSyncFailedListener;
eventEmitter.addListener('NODE_STARTED', () => {
    for (const listener of nodeStartedListeners) {
        listener();
    }
});
eventEmitter.addListener('NODE_FAILED_TO_START', error => {
    for (const listener of nodeFailedToStartListeners) {
        listener(error);
    }
});
eventEmitter.addListener('NODE_STOPPED', () => {
    for (const listener of nodeStoppedListeners) {
        listener();
    }
});
eventEmitter.addListener('NODE_FAILED_TO_STOP', error => {
    for (const listener of nodeFailedToStopListeners) {
        listener(error);
    }
});
eventEmitter.addListener('NODE_ONLINE', () => {
    for (const listener of nodeOnlineListeners) {
        listener();
    }
});
eventEmitter.addListener('WILL_STOP_NODE_IN_BACKGROUND_AFTER_DELAY', seconds => {
    for (const listener of willStopNodeInBackgroundAfterDelayListeners) {
        listener(seconds);
    }
});
eventEmitter.addListener('CANCELED_PENDING_NODE_STOP', () => {
    for (const listener of canceledPendingNodeStopListeners) {
        listener();
    }
});
eventEmitter.addListener('NOTIFICATION_RECEIVED', base64 => {
    const notification = model_1.Notification.decode(buffer_1.Buffer.from(base64, 'base64'));
    for (const listener of notificationReceivedListeners) {
        listener(notification);
    }
});
eventEmitter.addListener('THREAD_UPDATE_RECEIVED', (dict) => {
    const { threadId, block, type, data } = dict;
    const feedItemData = util_internal_1.toFeedItemData(type, block, data);
    for (const listener of threadUpdateReceivedListeners) {
        listener(threadId, feedItemData);
    }
});
eventEmitter.addListener('THREAD_ADDED', threadId => {
    for (const listener of threadAddedListeners) {
        listener(threadId);
    }
});
eventEmitter.addListener('THREAD_REMOVED', threadId => {
    for (const listener of threadRemovedListeners) {
        listener(threadId);
    }
});
eventEmitter.addListener('ACCOUNT_PEER_ADDED', peerId => {
    for (const listener of accountPeerAddedListeners) {
        listener(peerId);
    }
});
eventEmitter.addListener('ACCOUNT_PEER_REMOVED', peerId => {
    for (const listener of accountPeerRemovedListeners) {
        listener(peerId);
    }
});
eventEmitter.addListener('QUERY_DONE', queryId => {
    for (const listener of queryDoneListeners) {
        if (listener.queryId && listener.queryId === queryId) {
            listener.listener(queryId);
        }
        else {
            listener(queryId);
        }
    }
    pubsubQueryResultListeners = pubsubQueryResultListeners.filter(item => item.queryId !== queryId);
    queryDoneListeners = queryDoneListeners.filter(item => item.queryId !== queryId);
    queryErrorListeners = queryErrorListeners.filter(item => item.queryId !== queryId);
});
eventEmitter.addListener('QUERY_ERROR', payload => {
    const { queryId, error } = payload;
    for (const listener of queryErrorListeners) {
        if (listener.queryId && listener.queryId === queryId) {
            listener.listener(queryId, error);
        }
        else {
            listener(queryId, error);
        }
    }
});
eventEmitter.addListener('PUBSUB_QUERY_RESULT', payload => {
    const { queryId, message, messageId } = payload;
    for (const item of pubsubQueryResultListeners) {
        if (item.queryId === queryId) {
            item.listener(queryId, message, messageId);
        }
    }
});
eventEmitter.addListener('CLIENT_THREAD_QUERY_RESULT', payload => {
    const { queryId, data } = payload;
    const thread = model_1.Thread.decode(buffer_1.Buffer.from(data, 'base64'));
    for (const listener of clientThreadQueryResultListeners) {
        listener(queryId, thread);
    }
});
eventEmitter.addListener('CONTACT_QUERY_RESULT', payload => {
    const { queryId, data } = payload;
    const contact = model_1.Contact.decode(buffer_1.Buffer.from(data, 'base64'));
    for (const listener of contactQueryResultListeners) {
        listener(queryId, contact);
    }
});
eventEmitter.addListener('SYNC_UPDATE', base64 => {
    const status = model_1.CafeSyncGroupStatus.decode(buffer_1.Buffer.from(base64, 'base64'));
    for (const listener of syncUpdateListeners) {
        listener(status);
    }
});
eventEmitter.addListener('SYNC_COMPLETE', base64 => {
    const status = model_1.CafeSyncGroupStatus.decode(buffer_1.Buffer.from(base64, 'base64'));
    for (const listener of syncCompleteListeners) {
        listener(status);
    }
});
eventEmitter.addListener('SYNC_FAILED', base64 => {
    const status = model_1.CafeSyncGroupStatus.decode(buffer_1.Buffer.from(base64, 'base64'));
    for (const listener of syncFailedListeners) {
        listener(status);
    }
});