@highlight-run/rrweb 2.0.1 → 2.0.4

package/es/rrweb/packages/rrweb/src/replay/machine.js

@@ -1,321 +1,281 @@
-import { __assign, __values } from '../../ext/tslib/tslib.es6.js';
-import { interpret as v, createMachine as s, assign as o } from '../../../../ext/@xstate/fsm/es/index.js';
+import { interpret as v, createMachine as s, assign as o } from './../../../../ext/@xstate/fsm/es/index.js';
 import { EventType, IncrementalSource, ReplayerEvents } from '../types.js';
 import { addDelay } from './timer.js';
 
-function discardPriorSnapshots(events, baselineTime) {
-    for (var idx = events.length - 1; idx >= 0; idx--) {
-        var event_1 = events[idx];
-        if (event_1.type === EventType.Meta) {
-            if (event_1.timestamp <= baselineTime) {
-                return events.slice(idx);
-            }
-        }
-    }
-    return events;
-}
-function createPlayerService(context, _a) {
-    var getCastFn = _a.getCastFn, applyEventsSynchronously = _a.applyEventsSynchronously, emitter = _a.emitter;
-    var playerMachine = s({
-        id: 'player',
-        context: context,
-        initial: 'paused',
-        states: {
-            playing: {
-                on: {
-                    PAUSE: {
-                        target: 'paused',
-                        actions: ['pause'],
-                    },
-                    CAST_EVENT: {
-                        target: 'playing',
-                        actions: 'castEvent',
-                    },
-                    END: {
-                        target: 'paused',
-                        actions: ['resetLastPlayedEvent', 'pause'],
-                    },
-                    ADD_EVENT: {
-                        target: 'playing',
-                        actions: ['addEvent'],
-                    },
-                    REPLACE_EVENTS: {
-                        target: 'playing',
-                        actions: ['replaceEvents'],
-                    },
-                },
-            },
-            paused: {
-                on: {
-                    PLAY: {
-                        target: 'playing',
-                        actions: ['recordTimeOffset', 'play'],
-                    },
-                    CAST_EVENT: {
-                        target: 'paused',
-                        actions: 'castEvent',
-                    },
-                    TO_LIVE: {
-                        target: 'live',
-                        actions: ['startLive'],
-                    },
-                    ADD_EVENT: {
-                        target: 'paused',
-                        actions: ['addEvent'],
-                    },
-                    REPLACE_EVENTS: {
-                        target: 'paused',
-                        actions: ['replaceEvents'],
-                    },
-                },
-            },
-            live: {
-                on: {
-                    ADD_EVENT: {
-                        target: 'live',
-                        actions: ['addEvent'],
-                    },
-                    CAST_EVENT: {
-                        target: 'live',
-                        actions: ['castEvent'],
-                    },
-                },
-            },
-        },
-    }, {
-        actions: {
-            castEvent: o({
-                lastPlayedEvent: function (ctx, event) {
-                    if (event.type === 'CAST_EVENT') {
-                        return event.payload.event;
-                    }
-                    return ctx.lastPlayedEvent;
-                },
-            }),
-            recordTimeOffset: o(function (ctx, event) {
-                var timeOffset = ctx.timeOffset;
-                if ('payload' in event && 'timeOffset' in event.payload) {
-                    timeOffset = event.payload.timeOffset;
-                }
-                return __assign(__assign({}, ctx), { timeOffset: timeOffset, baselineTime: ctx.events[0].timestamp + timeOffset });
-            }),
-            play: function (ctx) {
-                var e_1, _a, e_2, _b;
-                var _c;
-                var timer = ctx.timer, events = ctx.events, baselineTime = ctx.baselineTime, lastPlayedEvent = ctx.lastPlayedEvent;
-                timer.clear();
-                try {
-                    for (var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
-                        var event_2 = events_1_1.value;
-                        addDelay(event_2, baselineTime);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                var neededEvents = discardPriorSnapshots(events, baselineTime);
-                var lastPlayedTimestamp = lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.timestamp;
-                if ((lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.type) === EventType.IncrementalSnapshot &&
-                    lastPlayedEvent.data.source === IncrementalSource.MouseMove) {
-                    lastPlayedTimestamp =
-                        lastPlayedEvent.timestamp +
-                            ((_c = lastPlayedEvent.data.positions[0]) === null || _c === void 0 ? void 0 : _c.timeOffset);
-                }
-                if (baselineTime < (lastPlayedTimestamp || 0)) {
-                    emitter.emit(ReplayerEvents.PlayBack);
-                }
-                var syncEvents = new Array();
-                var actions = new Array();
-                var _loop_1 = function (event_3) {
-                    if (lastPlayedTimestamp &&
-                        lastPlayedTimestamp < baselineTime &&
-                        (event_3.timestamp <= lastPlayedTimestamp ||
-                            event_3 === lastPlayedEvent)) {
-                        return "continue";
-                    }
-                    if (event_3.timestamp < baselineTime) {
-                        syncEvents.push(event_3);
-                    }
-                    else {
-                        var castFn_1 = getCastFn(event_3, false);
-                        actions.push({
-                            doAction: function () {
-                                castFn_1();
-                            },
-                            delay: event_3.delay,
-                        });
-                    }
-                };
-                try {
-                    for (var neededEvents_1 = __values(neededEvents), neededEvents_1_1 = neededEvents_1.next(); !neededEvents_1_1.done; neededEvents_1_1 = neededEvents_1.next()) {
-                        var event_3 = neededEvents_1_1.value;
-                        _loop_1(event_3);
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (neededEvents_1_1 && !neededEvents_1_1.done && (_b = neededEvents_1.return)) _b.call(neededEvents_1);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                applyEventsSynchronously(syncEvents);
-                emitter.emit(ReplayerEvents.Flush);
-                timer.addActions(actions);
-                timer.start();
-            },
-            pause: function (ctx) {
-                ctx.timer.clear();
-            },
-            resetLastPlayedEvent: o(function (ctx) {
-                return __assign(__assign({}, ctx), { lastPlayedEvent: null });
-            }),
-            startLive: o({
-                baselineTime: function (ctx, event) {
-                    ctx.timer.toggleLiveMode(true);
-                    ctx.timer.start();
-                    if (event.type === 'TO_LIVE' && event.payload.baselineTime) {
-                        return event.payload.baselineTime;
-                    }
-                    return Date.now();
-                },
-            }),
-            replaceEvents: o(function (ctx, machineEvent) {
-                var e_3, _a;
-                var curEvents = ctx.events, timer = ctx.timer, baselineTime = ctx.baselineTime;
-                if (machineEvent.type === 'REPLACE_EVENTS') {
-                    var newEvents = machineEvent.payload.events;
-                    curEvents.length = 0;
-                    var actions = [];
-                    var _loop_2 = function (event_4) {
-                        addDelay(event_4, baselineTime);
-                        curEvents.push(event_4);
-                        if (event_4.timestamp >= timer.timeOffset + baselineTime) {
-                            var castFn_2 = getCastFn(event_4, false);
-                            actions.push({
-                                doAction: function () {
-                                    castFn_2();
-                                },
-                                delay: event_4.delay,
-                            });
-                        }
-                    };
-                    try {
-                        for (var newEvents_1 = __values(newEvents), newEvents_1_1 = newEvents_1.next(); !newEvents_1_1.done; newEvents_1_1 = newEvents_1.next()) {
-                            var event_4 = newEvents_1_1.value;
-                            _loop_2(event_4);
-                        }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
-                        try {
-                            if (newEvents_1_1 && !newEvents_1_1.done && (_a = newEvents_1.return)) _a.call(newEvents_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                    }
-                    if (timer.isActive()) {
-                        timer.replaceActions(actions);
-                    }
-                }
-                return __assign(__assign({}, ctx), { events: curEvents });
-            }),
-            addEvent: o(function (ctx, machineEvent) {
-                var baselineTime = ctx.baselineTime, timer = ctx.timer, events = ctx.events;
-                if (machineEvent.type === 'ADD_EVENT') {
-                    var event_5 = machineEvent.payload.event;
-                    addDelay(event_5, baselineTime);
-                    var end = events.length - 1;
-                    if (!events[end] || events[end].timestamp <= event_5.timestamp) {
-                        events.push(event_5);
-                    }
-                    else {
-                        var insertionIndex = -1;
-                        var start = 0;
-                        while (start <= end) {
-                            var mid = Math.floor((start + end) / 2);
-                            if (events[mid].timestamp <= event_5.timestamp) {
-                                start = mid + 1;
-                            }
-                            else {
-                                end = mid - 1;
-                            }
-                        }
-                        if (insertionIndex === -1) {
-                            insertionIndex = start;
-                        }
-                        events.splice(insertionIndex, 0, event_5);
-                    }
-                    var isSync = event_5.timestamp < baselineTime;
-                    var castFn_3 = getCastFn(event_5, isSync);
-                    if (isSync) {
-                        castFn_3();
-                    }
-                    else if (timer.isActive()) {
-                        timer.addAction({
-                            doAction: function () {
-                                castFn_3();
-                            },
-                            delay: event_5.delay,
-                        });
-                    }
-                }
-                return __assign(__assign({}, ctx), { events: events });
-            }),
-        },
-    });
-    return v(playerMachine);
-}
-function createSpeedService(context) {
-    var speedMachine = s({
-        id: 'speed',
-        context: context,
-        initial: 'normal',
-        states: {
-            normal: {
-                on: {
-                    FAST_FORWARD: {
-                        target: 'skipping',
-                        actions: ['recordSpeed', 'setSpeed'],
-                    },
-                    SET_SPEED: {
-                        target: 'normal',
-                        actions: ['setSpeed'],
-                    },
-                },
-            },
-            skipping: {
-                on: {
-                    BACK_TO_NORMAL: {
-                        target: 'normal',
-                        actions: ['restoreSpeed'],
-                    },
-                    SET_SPEED: {
-                        target: 'normal',
-                        actions: ['setSpeed'],
-                    },
-                },
-            },
-        },
-    }, {
-        actions: {
-            setSpeed: function (ctx, event) {
-                if ('payload' in event) {
-                    ctx.timer.setSpeed(event.payload.speed);
-                }
-            },
-            recordSpeed: o({
-                normalSpeed: function (ctx) { return ctx.timer.speed; },
-            }),
-            restoreSpeed: function (ctx) {
-                ctx.timer.setSpeed(ctx.normalSpeed);
-            },
-        },
-    });
-    return v(speedMachine);
+function discardPriorSnapshots(events, baselineTime) {
+    for (let idx = events.length - 1; idx >= 0; idx--) {
+        const event = events[idx];
+        if (event.type === EventType.Meta) {
+            if (event.timestamp <= baselineTime) {
+                return events.slice(idx);
+            }
+        }
+    }
+    return events;
+}
+function createPlayerService(context, { getCastFn, applyEventsSynchronously, emitter }) {
+    const playerMachine = s({
+        id: 'player',
+        context,
+        initial: 'paused',
+        states: {
+            playing: {
+                on: {
+                    PAUSE: {
+                        target: 'paused',
+                        actions: ['pause'],
+                    },
+                    CAST_EVENT: {
+                        target: 'playing',
+                        actions: 'castEvent',
+                    },
+                    END: {
+                        target: 'paused',
+                        actions: ['resetLastPlayedEvent', 'pause'],
+                    },
+                    ADD_EVENT: {
+                        target: 'playing',
+                        actions: ['addEvent'],
+                    },
+                    REPLACE_EVENTS: {
+                        target: 'playing',
+                        actions: ['replaceEvents'],
+                    },
+                },
+            },
+            paused: {
+                on: {
+                    PLAY: {
+                        target: 'playing',
+                        actions: ['recordTimeOffset', 'play'],
+                    },
+                    CAST_EVENT: {
+                        target: 'paused',
+                        actions: 'castEvent',
+                    },
+                    TO_LIVE: {
+                        target: 'live',
+                        actions: ['startLive'],
+                    },
+                    ADD_EVENT: {
+                        target: 'paused',
+                        actions: ['addEvent'],
+                    },
+                    REPLACE_EVENTS: {
+                        target: 'paused',
+                        actions: ['replaceEvents'],
+                    },
+                },
+            },
+            live: {
+                on: {
+                    ADD_EVENT: {
+                        target: 'live',
+                        actions: ['addEvent'],
+                    },
+                    CAST_EVENT: {
+                        target: 'live',
+                        actions: ['castEvent'],
+                    },
+                },
+            },
+        },
+    }, {
+        actions: {
+            castEvent: o({
+                lastPlayedEvent: (ctx, event) => {
+                    if (event.type === 'CAST_EVENT') {
+                        return event.payload.event;
+                    }
+                    return ctx.lastPlayedEvent;
+                },
+            }),
+            recordTimeOffset: o((ctx, event) => {
+                let timeOffset = ctx.timeOffset;
+                if ('payload' in event && 'timeOffset' in event.payload) {
+                    timeOffset = event.payload.timeOffset;
+                }
+                return Object.assign(Object.assign({}, ctx), { timeOffset, baselineTime: ctx.events[0].timestamp + timeOffset });
+            }),
+            play(ctx) {
+                var _a;
+                const { timer, events, baselineTime, lastPlayedEvent } = ctx;
+                timer.clear();
+                for (const event of events) {
+                    addDelay(event, baselineTime);
+                }
+                const neededEvents = discardPriorSnapshots(events, baselineTime);
+                let lastPlayedTimestamp = lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.timestamp;
+                if ((lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.type) === EventType.IncrementalSnapshot &&
+                    lastPlayedEvent.data.source === IncrementalSource.MouseMove) {
+                    lastPlayedTimestamp =
+                        lastPlayedEvent.timestamp +
+                            ((_a = lastPlayedEvent.data.positions[0]) === null || _a === void 0 ? void 0 : _a.timeOffset);
+                }
+                if (baselineTime < (lastPlayedTimestamp || 0)) {
+                    emitter.emit(ReplayerEvents.PlayBack);
+                }
+                const syncEvents = new Array();
+                const actions = new Array();
+                for (const event of neededEvents) {
+                    if (lastPlayedTimestamp &&
+                        lastPlayedTimestamp < baselineTime &&
+                        (event.timestamp <= lastPlayedTimestamp ||
+                            event === lastPlayedEvent)) {
+                        continue;
+                    }
+                    if (event.timestamp < baselineTime) {
+                        syncEvents.push(event);
+                    }
+                    else {
+                        const castFn = getCastFn(event, false);
+                        actions.push({
+                            doAction: () => {
+                                castFn();
+                            },
+                            delay: event.delay,
+                        });
+                    }
+                }
+                applyEventsSynchronously(syncEvents);
+                emitter.emit(ReplayerEvents.Flush);
+                timer.addActions(actions);
+                timer.start();
+            },
+            pause(ctx) {
+                ctx.timer.clear();
+            },
+            resetLastPlayedEvent: o((ctx) => {
+                return Object.assign(Object.assign({}, ctx), { lastPlayedEvent: null });
+            }),
+            startLive: o({
+                baselineTime: (ctx, event) => {
+                    ctx.timer.toggleLiveMode(true);
+                    ctx.timer.start();
+                    if (event.type === 'TO_LIVE' && event.payload.baselineTime) {
+                        return event.payload.baselineTime;
+                    }
+                    return Date.now();
+                },
+            }),
+            replaceEvents: o((ctx, machineEvent) => {
+                const { events: curEvents, timer, baselineTime } = ctx;
+                if (machineEvent.type === 'REPLACE_EVENTS') {
+                    const { events: newEvents } = machineEvent.payload;
+                    curEvents.length = 0;
+                    const actions = [];
+                    for (const event of newEvents) {
+                        addDelay(event, baselineTime);
+                        curEvents.push(event);
+                        if (event.timestamp >= timer.timeOffset + baselineTime) {
+                            const castFn = getCastFn(event, false);
+                            actions.push({
+                                doAction: () => {
+                                    castFn();
+                                },
+                                delay: event.delay,
+                            });
+                        }
+                    }
+                    if (timer.isActive()) {
+                        timer.replaceActions(actions);
+                    }
+                }
+                return Object.assign(Object.assign({}, ctx), { events: curEvents });
+            }),
+            addEvent: o((ctx, machineEvent) => {
+                const { baselineTime, timer, events } = ctx;
+                if (machineEvent.type === 'ADD_EVENT') {
+                    const { event } = machineEvent.payload;
+                    addDelay(event, baselineTime);
+                    let end = events.length - 1;
+                    if (!events[end] || events[end].timestamp <= event.timestamp) {
+                        events.push(event);
+                    }
+                    else {
+                        let insertionIndex = -1;
+                        let start = 0;
+                        while (start <= end) {
+                            const mid = Math.floor((start + end) / 2);
+                            if (events[mid].timestamp <= event.timestamp) {
+                                start = mid + 1;
+                            }
+                            else {
+                                end = mid - 1;
+                            }
+                        }
+                        if (insertionIndex === -1) {
+                            insertionIndex = start;
+                        }
+                        events.splice(insertionIndex, 0, event);
+                    }
+                    const isSync = event.timestamp < baselineTime;
+                    const castFn = getCastFn(event, isSync);
+                    if (isSync) {
+                        castFn();
+                    }
+                    else if (timer.isActive()) {
+                        timer.addAction({
+                            doAction: () => {
+                                castFn();
+                            },
+                            delay: event.delay,
+                        });
+                    }
+                }
+                return Object.assign(Object.assign({}, ctx), { events });
+            }),
+        },
+    });
+    return v(playerMachine);
+}
+function createSpeedService(context) {
+    const speedMachine = s({
+        id: 'speed',
+        context,
+        initial: 'normal',
+        states: {
+            normal: {
+                on: {
+                    FAST_FORWARD: {
+                        target: 'skipping',
+                        actions: ['recordSpeed', 'setSpeed'],
+                    },
+                    SET_SPEED: {
+                        target: 'normal',
+                        actions: ['setSpeed'],
+                    },
+                },
+            },
+            skipping: {
+                on: {
+                    BACK_TO_NORMAL: {
+                        target: 'normal',
+                        actions: ['restoreSpeed'],
+                    },
+                    SET_SPEED: {
+                        target: 'normal',
+                        actions: ['setSpeed'],
+                    },
+                },
+            },
+        },
+    }, {
+        actions: {
+            setSpeed: (ctx, event) => {
+                if ('payload' in event) {
+                    ctx.timer.setSpeed(event.payload.speed);
+                }
+            },
+            recordSpeed: o({
+                normalSpeed: (ctx) => ctx.timer.speed,
+            }),
+            restoreSpeed: (ctx) => {
+                ctx.timer.setSpeed(ctx.normalSpeed);
+            },
+        },
+    });
+    return v(speedMachine);
 }
 
 export { createPlayerService, createSpeedService, discardPriorSnapshots };