@jesec/flood 0.0.0-master.485bb1f → 0.0.0-master.4867480

package/dist/server/services/index.js

@@ -1,108 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const clientGatewayService_1 = __importDefault(require("./clientGatewayService"));
-const clientRequestManager_1 = __importDefault(require("./clientRequestManager"));
-const feedService_1 = __importDefault(require("./feedService"));
-const historyService_1 = __importDefault(require("./historyService"));
-const notificationService_1 = __importDefault(require("./notificationService"));
-const taxonomyService_1 = __importDefault(require("./taxonomyService"));
-const torrentService_1 = __importDefault(require("./torrentService"));
-const clientRequestManagers = new Map();
-const clientGatewayServices = new Map();
-const feedServices = new Map();
-const historyServices = new Map();
-const notificationServices = new Map();
-const taxonomyServices = new Map();
-const torrentServices = new Map();
-const allServiceMaps = [
-    clientRequestManagers,
-    clientGatewayServices,
-    feedServices,
-    historyServices,
-    notificationServices,
-    taxonomyServices,
-    torrentServices,
-];
-const getService = ({ servicesMap, service: Service, user }) => {
-    let serviceInstance = servicesMap.get(user._id);
-    if (!serviceInstance) {
-        // eslint-disable-next-line no-use-before-define
-        serviceInstance = new Service(user, getAllServices(user));
-        servicesMap.set(user._id, serviceInstance);
-    }
-    return serviceInstance;
-};
-const getClientRequestManager = (user) => getService({ servicesMap: clientRequestManagers, service: clientRequestManager_1.default, user });
-const getClientGatewayService = (user) => getService({ servicesMap: clientGatewayServices, service: clientGatewayService_1.default, user });
-const getFeedService = (user) => getService({ servicesMap: feedServices, service: feedService_1.default, user });
-const getHistoryService = (user) => getService({ servicesMap: historyServices, service: historyService_1.default, user });
-const getNotificationService = (user) => getService({ servicesMap: notificationServices, service: notificationService_1.default, user });
-const getTaxonomyService = (user) => getService({ servicesMap: taxonomyServices, service: taxonomyService_1.default, user });
-const getTorrentService = (user) => getService({ servicesMap: torrentServices, service: torrentService_1.default, user });
-const bootstrapServicesForUser = (user) => {
-    getClientRequestManager(user);
-    getClientGatewayService(user);
-    getFeedService(user);
-    getHistoryService(user);
-    getNotificationService(user);
-    getTaxonomyService(user);
-    getTorrentService(user);
-};
-const destroyUserServices = (user) => {
-    const userId = user._id;
-    allServiceMaps.forEach((serviceMap) => {
-        const userService = serviceMap.get(userId);
-        if (userService != null) {
-            userService.destroy();
-            serviceMap.delete(userId);
-        }
-    });
-};
-const getAllServices = (user) => ({
-    get clientRequestManager() {
-        return getClientRequestManager(user);
-    },
-    get clientGatewayService() {
-        return getClientGatewayService(user);
-    },
-    get feedService() {
-        return getFeedService(user);
-    },
-    get historyService() {
-        return getHistoryService(user);
-    },
-    get notificationService() {
-        return getNotificationService(user);
-    },
-    get taxonomyService() {
-        return getTaxonomyService(user);
-    },
-    get torrentService() {
-        return getTorrentService(user);
-    },
-});
-const updateUserServices = (user) => {
-    const userId = user._id;
-    allServiceMaps.forEach((serviceMap) => {
-        const service = serviceMap.get(userId);
-        if (service != null) {
-            service.updateUser(user);
-            serviceMap.delete(userId);
-        }
-    });
-};
-exports.default = {
-    bootstrapServicesForUser,
-    destroyUserServices,
-    getAllServices,
-    getClientRequestManager,
-    getClientGatewayService,
-    getHistoryService,
-    getNotificationService,
-    getTaxonomyService,
-    getTorrentService,
-    updateUserServices,
-};

package/dist/server/services/notificationService.js

@@ -1,108 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
-const nedb_1 = __importDefault(require("nedb"));
-const path_1 = __importDefault(require("path"));
-const BaseService_1 = __importDefault(require("./BaseService"));
-const config_1 = __importDefault(require("../../config"));
-const notificationServiceEvents_1 = __importDefault(require("../constants/notificationServiceEvents"));
-const DEFAULT_QUERY_LIMIT = 20;
-const INITIAL_COUNT_VALUE = { read: 0, total: 0, unread: 0 };
-class NotificationService extends BaseService_1.default {
-    constructor(...serviceConfig) {
-        super(...serviceConfig);
-        this.count = { ...INITIAL_COUNT_VALUE };
-        this.ready = false;
-        this.db = this.loadDatabase();
-        this.emitUpdate = lodash_1.default.debounce(this.emitUpdate.bind(this), 100);
-        this.countNotifications();
-    }
-    addNotification(notifications) {
-        notifications = lodash_1.default.castArray(notifications);
-        this.count.total += notifications.length;
-        this.count.unread += notifications.length;
-        const timestamp = Date.now();
-        const notificationsToInsert = notifications.map((notification) => ({
-            ts: timestamp,
-            data: notification.data,
-            id: notification.id,
-            read: false,
-        }));
-        this.db.insert(notificationsToInsert, () => this.emitUpdate());
-    }
-    clearNotifications(options, callback) {
-        this.db.remove({}, { multi: true }, (err) => {
-            if (err) {
-                callback(null, err);
-                return;
-            }
-            this.count = { ...INITIAL_COUNT_VALUE };
-            callback();
-        });
-        this.emitUpdate();
-    }
-    countNotifications() {
-        this.db.find({}, (err, docs) => {
-            if (err) {
-                this.count = { ...INITIAL_COUNT_VALUE };
-            }
-            else {
-                docs.forEach((notification) => {
-                    if (notification.read) {
-                        this.count.read++;
-                    }
-                    else {
-                        this.count.unread++;
-                    }
-                    this.count.total++;
-                });
-            }
-            this.emitUpdate();
-        });
-    }
-    emitUpdate() {
-        this.emit(notificationServiceEvents_1.default.NOTIFICATION_COUNT_CHANGE, {
-            id: Date.now(),
-            data: this.count,
-        });
-    }
-    getNotificationCount() {
-        return this.count;
-    }
-    getNotifications(query, callback) {
-        const sortedNotifications = this.db.find({}).sort({ ts: -1 });
-        const queryCallback = (err, docs) => {
-            if (err) {
-                callback(null, err);
-                return;
-            }
-            callback({ notifications: docs, count: this.count });
-        };
-        if (query.allNotifications) {
-            sortedNotifications.exec(queryCallback);
-        }
-        else if (query.start != null) {
-            sortedNotifications
-                .skip(Number(query.start))
-                .limit(Number(query.limit) || DEFAULT_QUERY_LIMIT)
-                .exec(queryCallback);
-        }
-        else {
-            sortedNotifications.limit(Number(query.limit) || DEFAULT_QUERY_LIMIT).exec(queryCallback);
-        }
-    }
-    loadDatabase() {
-        if (this.ready)
-            return;
-        const db = new nedb_1.default({
-            autoload: true,
-            filename: path_1.default.join(config_1.default.dbPath, this.user._id, 'notifications.db'),
-        });
-        this.ready = true;
-        return db;
-    }
-}
-exports.default = NotificationService;

package/dist/server/services/taxonomyService.js

@@ -1,107 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BaseService_1 = __importDefault(require("./BaseService"));
-const clientGatewayServiceEvents_1 = __importDefault(require("../constants/clientGatewayServiceEvents"));
-const objectUtil_1 = __importDefault(require("../../shared/util/objectUtil"));
-const taxonomyServiceEvents_1 = __importDefault(require("../constants/taxonomyServiceEvents"));
-const torrentStatusMap_1 = __importDefault(require("../../shared/constants/torrentStatusMap"));
-class TaxonomyService extends BaseService_1.default {
-    constructor(...serviceConfig) {
-        super(...serviceConfig);
-        this.lastStatusCounts = { all: 0 };
-        this.lastTagCounts = { all: 0 };
-        this.lastTrackerCounts = { all: 0 };
-        this.statusCounts = { all: 0 };
-        this.tagCounts = { all: 0 };
-        this.trackerCounts = { all: 0 };
-        this.handleProcessTorrent = this.handleProcessTorrent.bind(this);
-        this.handleProcessTorrentListStart = this.handleProcessTorrentListStart.bind(this);
-        this.handleProcessTorrentListEnd = this.handleProcessTorrentListEnd.bind(this);
-        const { clientGatewayService } = this.services;
-        clientGatewayService.on(clientGatewayServiceEvents_1.default.PROCESS_TORRENT_LIST_START, this.handleProcessTorrentListStart);
-        clientGatewayService.on(clientGatewayServiceEvents_1.default.PROCESS_TORRENT_LIST_END, this.handleProcessTorrentListEnd);
-        clientGatewayService.on(clientGatewayServiceEvents_1.default.PROCESS_TORRENT, this.handleProcessTorrent);
-    }
-    destroy() {
-        const { clientGatewayService } = this.services;
-        clientGatewayService.removeListener(clientGatewayServiceEvents_1.default.PROCESS_TORRENT_LIST_START, this.handleProcessTorrentListStart);
-        clientGatewayService.removeListener(clientGatewayServiceEvents_1.default.PROCESS_TORRENT_LIST_END, this.handleProcessTorrentListEnd);
-        clientGatewayService.removeListener(clientGatewayServiceEvents_1.default.PROCESS_TORRENT, this.handleProcessTorrent);
-    }
-    getTaxonomy() {
-        return {
-            id: Date.now(),
-            taxonomy: {
-                statusCounts: this.statusCounts,
-                tagCounts: this.tagCounts,
-                trackerCounts: this.trackerCounts,
-            },
-        };
-    }
-    handleProcessTorrentListStart() {
-        this.lastStatusCounts = { ...this.statusCounts };
-        this.lastTagCounts = { ...this.tagCounts };
-        this.lastTrackerCounts = { ...this.trackerCounts };
-        torrentStatusMap_1.default.statusShorthand.forEach((statusShorthand) => {
-            this.statusCounts[torrentStatusMap_1.default[statusShorthand]] = 0;
-        });
-        this.statusCounts.all = 0;
-        this.tagCounts = { all: 0 };
-        this.trackerCounts = { all: 0 };
-    }
-    handleProcessTorrentListEnd(torrentList) {
-        const { length = 0 } = torrentList;
-        this.statusCounts.all = length;
-        this.tagCounts.all = length;
-        this.trackerCounts.all = length;
-        const taxonomyDiffs = {
-            statusCounts: objectUtil_1.default.getDiff(this.lastStatusCounts, this.statusCounts),
-            tagCounts: objectUtil_1.default.getDiff(this.lastTagCounts, this.tagCounts),
-            trackerCounts: objectUtil_1.default.getDiff(this.lastTrackerCounts, this.trackerCounts),
-        };
-        const didDiffChange = Object.keys(taxonomyDiffs).some((diffKey) => taxonomyDiffs[diffKey].length > 0);
-        if (didDiffChange) {
-            this.emit(taxonomyServiceEvents_1.default.TAXONOMY_DIFF_CHANGE, {
-                diff: taxonomyDiffs,
-                id: Date.now(),
-            });
-        }
-    }
-    handleProcessTorrent(torrentDetails) {
-        this.incrementStatusCounts(torrentDetails.status);
-        this.incrementTagCounts(torrentDetails.tags);
-        this.incrementTrackerCounts(torrentDetails.trackerURIs);
-    }
-    incrementStatusCounts(statuses) {
-        statuses.forEach((status) => {
-            this.statusCounts[torrentStatusMap_1.default[status]]++;
-        });
-    }
-    incrementTagCounts(tags) {
-        if (tags.length === 0) {
-            tags = ['untagged'];
-        }
-        tags.forEach((tag) => {
-            if (this.tagCounts[tag] != null) {
-                this.tagCounts[tag]++;
-            }
-            else {
-                this.tagCounts[tag] = 1;
-            }
-        });
-    }
-    incrementTrackerCounts(trackers) {
-        trackers.forEach((tracker) => {
-            if (this.trackerCounts[tracker] != null) {
-                this.trackerCounts[tracker]++;
-            }
-            else {
-                this.trackerCounts[tracker] = 1;
-            }
-        });
-    }
-}
-exports.default = TaxonomyService;

package/dist/server/services/torrentService.js

@@ -1,235 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const deep_equal_1 = __importDefault(require("deep-equal"));
-const BaseService_1 = __importDefault(require("./BaseService"));
-const clientGatewayServiceEvents_1 = __importDefault(require("../constants/clientGatewayServiceEvents"));
-const config_1 = __importDefault(require("../../config"));
-const formatUtil_1 = __importDefault(require("../../shared/util/formatUtil"));
-const methodCallUtil_1 = __importDefault(require("../util/methodCallUtil"));
-const serverEventTypes_1 = __importDefault(require("../../shared/constants/serverEventTypes"));
-const numberUtils_1 = __importDefault(require("../util/numberUtils"));
-const torrentListPropMap_1 = __importDefault(require("../constants/torrentListPropMap"));
-const torrentServiceEvents_1 = __importDefault(require("../constants/torrentServiceEvents"));
-const torrentStatusMap_1 = __importDefault(require("../../shared/constants/torrentStatusMap"));
-const torrentListMethodCallConfig = methodCallUtil_1.default.getMethodCallConfigFromPropMap(torrentListPropMap_1.default);
-const getTorrentETAFromDetails = (torrentDetails) => {
-    const { downRate, bytesDone, sizeBytes } = torrentDetails;
-    if (downRate > 0) {
-        return formatUtil_1.default.secondsToDuration((sizeBytes - bytesDone) / downRate);
-    }
-    return Infinity;
-};
-const getTorrentPercentCompleteFromDetails = (torrentDetails) => {
-    const percentComplete = (torrentDetails.bytesDone / torrentDetails.sizeBytes) * 100;
-    if (percentComplete > 0 && percentComplete < 10) {
-        return Number(numberUtils_1.default(percentComplete, 2));
-    }
-    if (percentComplete > 10 && percentComplete < 100) {
-        return Number(numberUtils_1.default(percentComplete, 1));
-    }
-    return percentComplete;
-};
-const getTorrentStatusFromDetails = (torrentDetails) => {
-    const { isHashing, isComplete, isOpen, upRate, downRate, state, message } = torrentDetails;
-    const torrentStatus = [];
-    if (isHashing !== '0') {
-        torrentStatus.push(torrentStatusMap_1.default.checking);
-    }
-    else if (isComplete && isOpen && state === '1') {
-        torrentStatus.push(torrentStatusMap_1.default.complete);
-        torrentStatus.push(torrentStatusMap_1.default.seeding);
-    }
-    else if (isComplete && isOpen && state === '0') {
-        torrentStatus.push(torrentStatusMap_1.default.stopped);
-    }
-    else if (isComplete && !isOpen) {
-        torrentStatus.push(torrentStatusMap_1.default.stopped);
-        torrentStatus.push(torrentStatusMap_1.default.complete);
-    }
-    else if (!isComplete && isOpen && state === '1') {
-        torrentStatus.push(torrentStatusMap_1.default.downloading);
-    }
-    else if (!isComplete && isOpen && state === '0') {
-        torrentStatus.push(torrentStatusMap_1.default.stopped);
-    }
-    else if (!isComplete && !isOpen) {
-        torrentStatus.push(torrentStatusMap_1.default.stopped);
-    }
-    if (message.length) {
-        torrentStatus.push(torrentStatusMap_1.default.error);
-    }
-    if (upRate !== 0) {
-        torrentStatus.push(torrentStatusMap_1.default.activelyUploading);
-    }
-    if (downRate !== 0) {
-        torrentStatus.push(torrentStatusMap_1.default.activelyDownloading);
-    }
-    if (upRate !== 0 || downRate !== 0) {
-        torrentStatus.push(torrentStatusMap_1.default.active);
-    }
-    else {
-        torrentStatus.push(torrentStatusMap_1.default.inactive);
-    }
-    return torrentStatus;
-};
-const hasTorrentFinished = (prevData = {}, nextData = {}) => {
-    const { status = [] } = prevData;
-    return (!status.includes(torrentStatusMap_1.default.checking) && prevData.percentComplete < 100 && nextData.percentComplete === 100);
-};
-class TorrentService extends BaseService_1.default {
-    constructor(...serviceConfig) {
-        super(...serviceConfig);
-        this.errorCount = 0;
-        this.pollTimeout = null;
-        this.torrentListSummary = { torrents: {} };
-        this.fetchTorrentList = this.fetchTorrentList.bind(this);
-        this.handleTorrentProcessed = this.handleTorrentProcessed.bind(this);
-        this.handleTorrentsRemoved = this.handleTorrentsRemoved.bind(this);
-        this.handleFetchTorrentListSuccess = this.handleFetchTorrentListSuccess.bind(this);
-        this.handleFetchTorrentListError = this.handleFetchTorrentListError.bind(this);
-        const { clientGatewayService } = this.services;
-        clientGatewayService.addTorrentListReducer({
-            key: 'status',
-            reduce: getTorrentStatusFromDetails,
-        });
-        clientGatewayService.addTorrentListReducer({
-            key: 'percentComplete',
-            reduce: getTorrentPercentCompleteFromDetails,
-        });
-        clientGatewayService.addTorrentListReducer({
-            key: 'eta',
-            reduce: getTorrentETAFromDetails,
-        });
-        clientGatewayService.on(clientGatewayServiceEvents_1.default.PROCESS_TORRENT, this.handleTorrentProcessed);
-        clientGatewayService.on(clientGatewayServiceEvents_1.default.TORRENTS_REMOVED, this.handleTorrentsRemoved);
-        this.fetchTorrentList();
-    }
-    assignDeletedTorrentsToDiff(diff, nextTorrentListSummary, options = {}) {
-        const { newTorrentCount = 0 } = options;
-        // We need to look for deleted torrents in two scenarios:
-        // 1. the next list length is less than than the current length
-        // 2. at least one new torrent was added and the next list length is
-        //    equal to or greater than the current list length.
-        //
-        // We definitely don't need to look for deleted torrents if the number
-        // of new torrents is equal to the difference between next torrent list
-        // length and previous torrent list length.
-        let shouldLookForDeletedTorrents = nextTorrentListSummary.length < this.torrentListSummary.length;
-        if (newTorrentCount > 0) {
-            if (nextTorrentListSummary.length >= this.torrentListSummary.length) {
-                shouldLookForDeletedTorrents = true;
-            }
-            if (newTorrentCount === nextTorrentListSummary.length - this.torrentListSummary.length) {
-                shouldLookForDeletedTorrents = false;
-            }
-        }
-        if (shouldLookForDeletedTorrents) {
-            Object.keys(this.torrentListSummary.torrents).forEach((hash) => {
-                if (nextTorrentListSummary.torrents[hash] == null) {
-                    diff[hash] = {
-                        action: serverEventTypes_1.default.TORRENT_LIST_ACTION_TORRENT_DELETED,
-                    };
-                }
-            }, {});
-        }
-    }
-    deferFetchTorrentList(interval = config_1.default.torrentClientPollInterval || 2000) {
-        this.pollTimeout = setTimeout(this.fetchTorrentList, interval);
-    }
-    destroy() {
-        clearTimeout(this.pollTimeout);
-    }
-    fetchTorrentList() {
-        if (this.pollTimeout != null) {
-            clearTimeout(this.pollTimeout);
-        }
-        return this.services.clientGatewayService
-            .fetchTorrentList(torrentListMethodCallConfig)
-            .then(this.handleFetchTorrentListSuccess)
-            .catch(this.handleFetchTorrentListError);
-    }
-    getTorrent(hash) {
-        return this.torrentListSummary.torrents[hash];
-    }
-    getTorrentList() {
-        return this.torrentListSummary;
-    }
-    getTorrentListDiff(nextTorrentListSummary) {
-        let newTorrentCount = 0;
-        // Get the diff...
-        const diff = Object.keys(nextTorrentListSummary.torrents).reduce((accumulator, hash) => {
-            const currentTorrentDetails = this.torrentListSummary.torrents[hash];
-            const nextTorrentDetails = nextTorrentListSummary.torrents[hash];
-            // If the current torrent list doesn't contain any details for this
-            // hash, then it's a brand new torrent, so every detail is part of the
-            // diff.
-            if (currentTorrentDetails == null) {
-                accumulator[hash] = {
-                    action: serverEventTypes_1.default.TORRENT_LIST_ACTION_TORRENT_ADDED,
-                    data: nextTorrentDetails,
-                };
-                // Track the number of new torrents added.
-                newTorrentCount++;
-            }
-            else {
-                Object.keys(nextTorrentDetails).forEach((propKey) => {
-                    // If one of the details is inequal, we need to add it to the diff.
-                    if (!deep_equal_1.default(currentTorrentDetails[propKey], nextTorrentDetails[propKey])) {
-                        // Initialize with an empty object when this is the first known
-                        // inequal property.
-                        if (accumulator[hash] == null) {
-                            accumulator[hash] = {
-                                action: serverEventTypes_1.default.TORRENT_LIST_ACTION_TORRENT_DETAIL_UPDATED,
-                                data: {},
-                            };
-                        }
-                        // Add the diff details.
-                        accumulator[hash].data[propKey] = nextTorrentDetails[propKey];
-                    }
-                });
-            }
-            return accumulator;
-        }, {});
-        this.assignDeletedTorrentsToDiff(diff, nextTorrentListSummary, { newTorrentCount });
-        return diff;
-    }
-    handleFetchTorrentListError() {
-        let nextInterval = config_1.default.torrentClientPollInterval || 2000;
-        // If more than consecutive errors have occurred, then we delay the next
-        // request.
-        if (++this.errorCount >= 3) {
-            nextInterval = Math.min(nextInterval + 2 ** this.errorCount, 1000 * 60);
-        }
-        this.deferFetchTorrentList(nextInterval);
-        this.emit(torrentServiceEvents_1.default.FETCH_TORRENT_LIST_ERROR);
-    }
-    getTorrentListSummary() {
-        return this.torrentListSummary;
-    }
-    handleFetchTorrentListSuccess(nextTorrentListSummary) {
-        const diff = this.getTorrentListDiff(nextTorrentListSummary);
-        if (Object.keys(diff).length > 0) {
-            this.emit(torrentServiceEvents_1.default.TORRENT_LIST_DIFF_CHANGE, { diff, id: nextTorrentListSummary.id });
-        }
-        this.torrentListSummary = nextTorrentListSummary;
-        this.deferFetchTorrentList();
-        this.errorCount = 0;
-        this.emit(torrentServiceEvents_1.default.FETCH_TORRENT_LIST_SUCCESS);
-    }
-    handleTorrentProcessed(nextTorrentDetails) {
-        const prevTorrentDetails = this.torrentListSummary.torrents[nextTorrentDetails.hash];
-        if (hasTorrentFinished(prevTorrentDetails, nextTorrentDetails)) {
-            this.services.notificationService.addNotification({
-                id: 'notification.torrent.finished',
-                data: { name: nextTorrentDetails.name },
-            });
-        }
-    }
-    handleTorrentsRemoved() {
-        this.fetchTorrentList();
-    }
-}
-exports.default = TorrentService;

package/dist/server/util/ajaxUtil.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ajaxUtil = {
-    getResponseFn: (res) => (data, error) => {
-        if (error) {
-            if (process.env.NODE_ENV === 'development') {
-                console.trace(error);
-            }
-            if (typeof error === 'string') {
-                error = Error(error);
-            }
-            res.status(500).json(error);
-        }
-        else {
-            res.json(data);
-        }
-    },
-};
-exports.default = ajaxUtil;

package/dist/server/util/clientResponseUtil.js

@@ -1,99 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const geoip_country_1 = __importDefault(require("geoip-country"));
-const numberUtils_1 = __importDefault(require("./numberUtils"));
-const torrentFilePropsMap_1 = __importDefault(require("../../shared/constants/torrentFilePropsMap"));
-const torrentPeerPropsMap_1 = __importDefault(require("../../shared/constants/torrentPeerPropsMap"));
-const torrentTrackerPropsMap_1 = __importDefault(require("../../shared/constants/torrentTrackerPropsMap"));
-const processFile = (file) => {
-    file.filename = file.pathComponents[file.pathComponents.length - 1];
-    file.percentComplete = numberUtils_1.default((file.completedChunks / file.sizeChunks) * 100);
-    delete file.completedChunks;
-    delete file.pathComponents;
-    delete file.sizeChunks;
-    return file;
-};
-const getFileTreeFromPathsArr = (tree, directory, file, depth) => {
-    if (depth == null) {
-        depth = 0;
-    }
-    if (tree == null) {
-        tree = {};
-    }
-    if (depth++ < file.pathComponents.length - 1) {
-        if (!tree.directories) {
-            tree.directories = {};
-        }
-        tree.directories[directory] = getFileTreeFromPathsArr(tree.directories[directory], file.pathComponents[depth], file, depth);
-    }
-    else {
-        if (!tree.files) {
-            tree.files = [];
-        }
-        tree.files.push(processFile(file));
-    }
-    return tree;
-};
-const mapPropsToResponse = (requestedKeys, clientResponse) => {
-    if (clientResponse.length === 0) {
-        return [];
-    }
-    // clientResponse is always an array of arrays.
-    if (clientResponse[0].length === 1) {
-        // When the length of the nested arrays is 1, the nested arrays represent a
-        // singular requested value (e.g. total data transferred or current upload
-        // speed). Therefore we construct an object where the requested keys map to
-        // their values.
-        return clientResponse.reduce((memo, value, index) => {
-            const singleValue = value[0];
-            memo[requestedKeys[index]] = singleValue;
-            return memo;
-        }, {});
-    }
-    // When the length of the nested arrays is more than 1, the nested arrays
-    // represent one of many items of the same type (e.g. a list of torrents,
-    // peers, files, etc). Therefore we construct an array of objects, where each
-    // object contains all of the requested keys and its value. We add an index
-    // for each item, a requirement for file lists.
-    return clientResponse.map((listItem, index) => listItem.reduce((nestedMemo, value, nestedIndex) => {
-        nestedMemo[requestedKeys[nestedIndex]] = value;
-        return nestedMemo;
-    }, { index }), []);
-};
-const processTorrentDetails = (data) => {
-    // TODO: This is ugly.
-    const peersData = data[0][0] || null;
-    const filesData = data[1][0] || null;
-    const trackerData = data[2][0] || null;
-    let peers = null;
-    let files = null;
-    let trackers = null;
-    let fileTree = {};
-    if (peersData && peersData.length) {
-        peers = mapPropsToResponse(torrentPeerPropsMap_1.default.props, peersData).map((peer) => {
-            const geoData = geoip_country_1.default.lookup(peer.address) || {};
-            peer.country = geoData.country;
-            // Strings to boolean
-            peer.isEncrypted = peer.isEncrypted === '1';
-            peer.isIncoming = peer.isIncoming === '1';
-            return peer;
-        });
-    }
-    if (filesData && filesData.length) {
-        files = mapPropsToResponse(torrentFilePropsMap_1.default.props, filesData);
-        fileTree = files.reduce((memo, file) => getFileTreeFromPathsArr(memo, file.pathComponents[0], file), {});
-    }
-    if (trackerData && trackerData.length) {
-        trackers = mapPropsToResponse(torrentTrackerPropsMap_1.default.props, trackerData);
-    }
-    return { peers, trackers, fileTree };
-};
-const clientResponseUtil = {
-    mapPropsToResponse,
-    processFile,
-    processTorrentDetails,
-};
-exports.default = clientResponseUtil;