402 lines
13 KiB
TypeScript
402 lines
13 KiB
TypeScript
// Module ID: 7331
|
|
// Function ID: 7332
|
|
// Name: AnalyticsFeedItemSeenManager
|
|
// Dependencies: [5, 38, 585, 2]
|
|
|
|
// Module 7331 (AnalyticsFeedItemSeenManager)
|
|
import _modDef38 from "module_38" /* 38 */;
|
|
import DispatcherDefault from "Dispatcher" /* 585 */;
|
|
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
|
|
import size from "module_2" /* 2 */;
|
|
|
|
let c1, c2, c3, set;
|
|
|
|
const ForceFlushType = { IMMEDIATE: 0, [0]: "IMMEDIATE", IMMEDIATE_WITH_COOLDOWN: 1, [1]: "IMMEDIATE_WITH_COOLDOWN", IMMEDIATE_WITH_DELAY: 2, [2]: "IMMEDIATE_WITH_DELAY" };
|
|
class TrackedFeedItem {
|
|
constructor() {
|
|
const obj = Object.create(new.target.prototype);
|
|
obj.seenIntervals = [];
|
|
return obj;
|
|
}
|
|
maybeMarkSeen(startTimeMillis) {
|
|
let flag = null == tmp || null != tmp.endTimeMillis;
|
|
if (flag) {
|
|
const seenIntervals = this.seenIntervals;
|
|
const obj = { startTimeMillis };
|
|
seenIntervals.push(obj);
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
maybeMarkUnseen(endTimeMillis) {
|
|
let flag = null != tmp && null == tmp.endTimeMillis;
|
|
if (flag) {
|
|
this.seenIntervals[this.seenIntervals.length - 1].endTimeMillis = endTimeMillis;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
isVisible() {
|
|
let startTimeMillis;
|
|
if (this.seenIntervals[this.seenIntervals.length - 1] != null) {
|
|
startTimeMillis = tmp.startTimeMillis;
|
|
}
|
|
let tmp3 = null != startTimeMillis;
|
|
if (tmp3) {
|
|
let endTimeMillis;
|
|
if (this.seenIntervals[this.seenIntervals.length - 1] != null) {
|
|
endTimeMillis = tmp.endTimeMillis;
|
|
}
|
|
tmp3 = null == endTimeMillis;
|
|
}
|
|
return tmp3;
|
|
}
|
|
computeSeenTimeDestructive(isForcedFlush) {
|
|
let num = 0;
|
|
const items = [];
|
|
const iter = this.seenIntervals[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp2 = nextResult;
|
|
if (null == nextResult.endTimeMillis) {
|
|
if (isForcedFlush) {
|
|
let _Date = Date;
|
|
let timestamp = Date.now();
|
|
num = num + (timestamp - tmp2.startTimeMillis);
|
|
let obj = { startTimeMillis: timestamp };
|
|
let arr = items.push(obj);
|
|
} else {
|
|
let arr3 = items.push(tmp2);
|
|
}
|
|
} else {
|
|
num = num + (tmp2.endTimeMillis - tmp2.startTimeMillis);
|
|
}
|
|
continue;
|
|
}
|
|
_modDef38(items.length < 2, "there should only be a single left over data");
|
|
this.seenIntervals = items;
|
|
return Math.round(num);
|
|
}
|
|
}
|
|
const prototype = TrackedFeedItem.prototype;
|
|
let result = size.fileFinishedImporting("utils/AnalyticsFeedItemSeenManager.tsx");
|
|
class AnalyticsFeedItemSeenManager {
|
|
constructor(isPaused) {
|
|
let id;
|
|
let windowId;
|
|
let flag = isPaused.isPaused;
|
|
({ id, windowId } = isPaused);
|
|
let obj = Object.create(new.target.prototype);
|
|
obj.initialize = function initialize() {
|
|
obj = DispatcherDefault;
|
|
const subscription = obj.subscribe("ANALYTICS_FEED_ITEM_SEEN", obj.handleFeedItemSeen);
|
|
const obj2 = DispatcherDefault;
|
|
const subscription1 = obj2.subscribe("ANALYTICS_FEED_ITEM_UNSEEN", obj.handleFeedItemUnseen);
|
|
const obj3 = DispatcherDefault;
|
|
const subscription2 = obj3.subscribe("ANALYTICS_FEED_FLUSH", obj.handleFeedItemFlush);
|
|
const obj4 = DispatcherDefault;
|
|
const subscription3 = obj4.subscribe("APP_STATE_UPDATE", obj.handleAppStateUpdate);
|
|
const obj5 = DispatcherDefault;
|
|
const subscription4 = obj5.subscribe("WINDOW_FOCUS", obj.handleWindowFocus);
|
|
const onInitialize = obj.onInitialize;
|
|
if (onInitialize != null) {
|
|
onInitialize();
|
|
}
|
|
};
|
|
obj.terminate = function terminate() {
|
|
obj = DispatcherDefault;
|
|
obj.unsubscribe("ANALYTICS_FEED_ITEM_SEEN", obj.handleFeedItemSeen);
|
|
const obj3 = DispatcherDefault;
|
|
obj3.unsubscribe("ANALYTICS_FEED_ITEM_UNSEEN", obj.handleFeedItemUnseen);
|
|
const obj4 = DispatcherDefault;
|
|
obj4.unsubscribe("ANALYTICS_FEED_FLUSH", obj.handleFeedItemFlush);
|
|
const obj5 = DispatcherDefault;
|
|
obj5.unsubscribe("APP_STATE_UPDATE", obj.handleAppStateUpdate);
|
|
const obj6 = DispatcherDefault;
|
|
obj6.unsubscribe("WINDOW_FOCUS", obj.handleWindowFocus);
|
|
const onTerminate = obj.onTerminate;
|
|
const obj2 = obj;
|
|
if (onTerminate != null) {
|
|
onTerminate();
|
|
}
|
|
obj2.maybeFlushSeenItems(obj.IMMEDIATE);
|
|
};
|
|
obj.handleFeedItemFlush = function handleFeedItemFlush(id) {
|
|
if (obj._id === id.id) {
|
|
obj.maybeFlushSeenItems(tmp);
|
|
}
|
|
};
|
|
obj.handleFeedItemSeen = function handleFeedItemSeen(feedItemId) {
|
|
feedItemId = feedItemId.feedItemId;
|
|
if (feedItemId.id === obj._id) {
|
|
if (obj._paused) {
|
|
const _pausedFeedItemIds = obj._pausedFeedItemIds;
|
|
_pausedFeedItemIds.add(feedItemId);
|
|
} else {
|
|
const trackedFeedItem = obj.getTrackedFeedItem(feedItemId);
|
|
const onFeedItemSeen = obj.onFeedItemSeen;
|
|
if (onFeedItemSeen != null) {
|
|
onFeedItemSeen(feedItemId, trackedFeedItem.maybeMarkSeen(tmp));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
obj.handleFeedItemUnseen = function handleFeedItemUnseen(feedItemId) {
|
|
feedItemId = feedItemId.feedItemId;
|
|
if (feedItemId.id === obj._id) {
|
|
if (obj._paused) {
|
|
const _pausedFeedItemIds = obj._pausedFeedItemIds;
|
|
_pausedFeedItemIds.delete(feedItemId);
|
|
}
|
|
const trackedFeedItem = obj.getTrackedFeedItem(feedItemId);
|
|
const onFeedItemUnseen = obj.onFeedItemUnseen;
|
|
if (onFeedItemUnseen != null) {
|
|
onFeedItemUnseen(feedItemId, trackedFeedItem.maybeMarkUnseen(tmp));
|
|
}
|
|
obj.maybeFlushSeenItems();
|
|
}
|
|
};
|
|
obj.getTrackedFeedItem = function getTrackedFeedItem(feedItemId) {
|
|
const tmp = obj;
|
|
if (null == obj.trackedFeedItems[feedItemId]) {
|
|
const self = this;
|
|
if (typeof TrackedFeedItem === "function") {
|
|
obj = Object.create(TrackedFeedItem.prototype);
|
|
obj.seenIntervals = [];
|
|
tmp2[feedItemId] = obj;
|
|
} else {
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
}
|
|
return tmp.trackedFeedItems[feedItemId];
|
|
};
|
|
obj.getVisibleFeedItemIds = function getVisibleFeedItemIds() {
|
|
let trackedFeedItems;
|
|
const keys = Object.keys(obj.trackedFeedItems);
|
|
set = new Set(keys.filter((item) => {
|
|
let isVisibleResult;
|
|
if (trackedFeedItems.trackedFeedItems[item] != null) {
|
|
isVisibleResult = obj.isVisible();
|
|
}
|
|
return isVisibleResult;
|
|
}));
|
|
return set;
|
|
};
|
|
obj.handleAppStateUpdate = function handleAppStateUpdate(state) {
|
|
state = state.state;
|
|
const _isReactNavigationFocused = "active" === state && obj._isReactNavigationFocused;
|
|
if (_isReactNavigationFocused) {
|
|
obj.resume();
|
|
}
|
|
if ("background" === state) {
|
|
if (obj._isReactNavigationFocused) {
|
|
obj.pause();
|
|
}
|
|
obj.maybeFlushSeenItems(obj.IMMEDIATE);
|
|
}
|
|
};
|
|
obj.clearPausedFeedItemIds = function clearPausedFeedItemIds() {
|
|
obj._pausedFeedItemIds = new Set();
|
|
obj._paused = false;
|
|
new Set();
|
|
};
|
|
obj.pause = function pause() {
|
|
if (!obj._paused) {
|
|
const visibleFeedItemIds = obj.getVisibleFeedItemIds();
|
|
const item = visibleFeedItemIds.forEach((feedItemId) => {
|
|
obj = { id: closure_1_0._id, feedItemId, timestampMillis: Date.now(), type: "ANALYTICS_FEED_ITEM_UNSEEN" };
|
|
closure_1_0.handleFeedItemUnseen(obj);
|
|
});
|
|
obj._paused = true;
|
|
obj._pausedFeedItemIds = visibleFeedItemIds;
|
|
}
|
|
};
|
|
obj.resume = function resume() {
|
|
if (obj._paused) {
|
|
obj._paused = false;
|
|
const _pausedFeedItemIds = obj._pausedFeedItemIds;
|
|
const item = _pausedFeedItemIds.forEach((feedItemId) => {
|
|
obj = { id: closure_1_0._id, feedItemId, timestampMillis: Date.now(), type: "ANALYTICS_FEED_ITEM_SEEN" };
|
|
closure_1_0.handleFeedItemSeen(obj);
|
|
});
|
|
const result = obj.clearPausedFeedItemIds();
|
|
}
|
|
};
|
|
obj.handleReactNavigationFocus = function handleReactNavigationFocus(_isReactNavigationFocused) {
|
|
obj._isReactNavigationFocused = _isReactNavigationFocused;
|
|
if (obj._isReactNavigationFocused) {
|
|
obj.resume();
|
|
} else {
|
|
obj.pause();
|
|
}
|
|
};
|
|
obj.handleWindowFocus = function handleWindowFocus(windowId) {
|
|
if (obj._windowId === windowId.windowId) {
|
|
if (windowId.focused) {
|
|
obj.resume();
|
|
} else {
|
|
obj.pause();
|
|
}
|
|
}
|
|
};
|
|
obj.trackedFeedItems = {};
|
|
obj._id = id;
|
|
obj._windowId = windowId;
|
|
set = new Set();
|
|
obj._pausedFeedItemIds = set;
|
|
if (flag == null) {
|
|
flag = false;
|
|
}
|
|
obj._paused = flag;
|
|
obj._isReactNavigationFocused = true;
|
|
obj._lastFlushTimeMillis = Date.now();
|
|
return obj;
|
|
}
|
|
maybeFlushSeenItems(IMMEDIATE) {
|
|
let obj;
|
|
let resolved;
|
|
const self = this;
|
|
if (null == IMMEDIATE) {
|
|
const tmp = globalThis;
|
|
const _Date = Date;
|
|
if (Date.now() - self._lastFlushTimeMillis < 60000) {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
const tmp2 = obj;
|
|
if (IMMEDIATE === obj.IMMEDIATE_WITH_COOLDOWN) {
|
|
const tmp3 = globalThis;
|
|
const _Date2 = Date;
|
|
if (Date.now() - self._lastFlushTimeMillis < 3000) {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
const flushSeenItemsFunction = self.createFlushSeenItemsFunction(IMMEDIATE);
|
|
if (null == flushSeenItemsFunction) {
|
|
resolved = Promise.resolve();
|
|
} else {
|
|
const tmp8 = globalThis;
|
|
const _Date3 = Date;
|
|
self._lastFlushTimeMillis = Date.now();
|
|
if (IMMEDIATE !== tmp2.IMMEDIATE) {
|
|
if (IMMEDIATE !== tmp2.IMMEDIATE_WITH_COOLDOWN) {
|
|
const self2 = this;
|
|
const self3 = this;
|
|
resolved = new Promise((arg0) => {
|
|
let closure_0 = arg0;
|
|
const timerId = setTimeout(_asyncToGenerator(async (arg0, value) => {
|
|
if (c2 === 2) {
|
|
c2 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp2 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
const obj2 = { value, done: true };
|
|
return obj2;
|
|
} else {
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c2 = 2;
|
|
if (0 === c1) {
|
|
if (arg0 === 1) {
|
|
c2 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c2 = 3;
|
|
const obj3 = { value, done: true };
|
|
return obj3;
|
|
} else {
|
|
c1 = 1;
|
|
c2 = 1;
|
|
const obj4 = { value: tmp3(), done: false };
|
|
return obj4;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c2 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c2 = 3;
|
|
const obj = { value, done: true };
|
|
return obj;
|
|
} else {
|
|
closure_128_0();
|
|
c2 = 3;
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} catch (tmp8) {
|
|
c2 = 3;
|
|
throw tmp8;
|
|
}
|
|
}
|
|
}), 100);
|
|
});
|
|
}
|
|
}
|
|
let closure_0 = _asyncToGenerator(async (arg0, value) => {
|
|
closure_0 = arg0;
|
|
if (c3 === 2) {
|
|
c3 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
const obj2 = { value, done: true };
|
|
return obj2;
|
|
} else {
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c3 = 2;
|
|
if (0 === c2) {
|
|
if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
const obj3 = { value, done: true };
|
|
return obj3;
|
|
} else {
|
|
let closure_1 = tmp;
|
|
c2 = 1;
|
|
c3 = 1;
|
|
const obj4 = { value: closure_0(), done: false };
|
|
return obj4;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
const obj = { value, done: true };
|
|
return obj;
|
|
} else {
|
|
closure_0();
|
|
c3 = 3;
|
|
return { value: "IconComponent", done: null };
|
|
}
|
|
} catch (tmp10) {
|
|
c3 = 3;
|
|
throw tmp10;
|
|
}
|
|
}
|
|
});
|
|
const self4 = this;
|
|
const self5 = this;
|
|
resolved = new Promise(function() {
|
|
return closure_0(...arguments);
|
|
});
|
|
}
|
|
return resolved;
|
|
}
|
|
}
|
|
const prototype2 = AnalyticsFeedItemSeenManager.prototype;
|
|
|
|
export const AnalyticsFeedTypes = { FORUM_CHANNEL: "forum_channel" };
|
|
export { ForceFlushType };
|
|
export { TrackedFeedItem };
|
|
export { AnalyticsFeedItemSeenManager };
|