clarity-js 0.8.6 → 0.8.8

package/src/interaction/selection.ts

@@ -1,68 +1,68 @@
-import { Event } from "@clarity-types/data";
-import { SelectionData, Setting } from "@clarity-types/interaction";
-import { FunctionNames } from "@clarity-types/performance";
-import { bind } from "@src/core/event";
-import { schedule } from "@src/core/task";
-import { clearTimeout, setTimeout } from "@src/core/timeout";
-import encode from "./encode";
-
-export let data: SelectionData = null;
-let previous: Selection = null;
-let timeout: number = null;
-
-export function start(): void {
-    reset();
-}
-
-export function observe(root: Node): void {
-    bind(root, "selectstart", recompute.bind(this, root), true);
-    bind(root, "selectionchange", recompute.bind(this, root), true);
-}
-
-function recompute(root: Node): void {
-    recompute.dn = FunctionNames.SelectionRecompute;
-    let doc = root.nodeType === Node.DOCUMENT_NODE ? root as Document : document;
-    let current = doc.getSelection();
-
-    // Bail out if we don't have a valid selection
-    if (current === null) { return; }
-
-    // Bail out if we got a valid selection but not valid nodes
-    // In Edge, selectionchange gets fired even on interactions like right clicks and
-    // can result in null anchorNode and focusNode if there was no previous selection on page
-    // Also, ignore any selections that start and end at the exact same point
-    if ((current.anchorNode === null && current.focusNode === null) ||
-        (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)) {
-        return;
-    }
-    let startNode = data.start ? data.start : null;
-    if (previous !== null && data.start !== null && startNode !== current.anchorNode) {
-        clearTimeout(timeout);
-        process(Event.Selection);
-    }
-
-    data = {
-        start: current.anchorNode,
-        startOffset: current.anchorOffset,
-        end: current.focusNode,
-        endOffset: current.focusOffset
-    };
-    previous = current;
-
-    clearTimeout(timeout);
-    timeout = setTimeout(process, Setting.LookAhead, Event.Selection);
-}
-
-function process(event: Event): void {
-    schedule(encode.bind(this, event));
-}
-
-export function reset(): void {
-    previous = null;
-    data = { start: 0, startOffset: 0, end: 0, endOffset: 0 };
-}
-
-export function stop(): void {
-    reset();
-    clearTimeout(timeout);
-}
+import { Event } from "@clarity-types/data";
+import { SelectionData, Setting } from "@clarity-types/interaction";
+import { FunctionNames } from "@clarity-types/performance";
+import { bind } from "@src/core/event";
+import { schedule } from "@src/core/task";
+import { clearTimeout, setTimeout } from "@src/core/timeout";
+import encode from "./encode";
+
+export let data: SelectionData = null;
+let previous: Selection = null;
+let timeout: number = null;
+
+export function start(): void {
+    reset();
+}
+
+export function observe(root: Node): void {
+    bind(root, "selectstart", recompute.bind(this, root), true);
+    bind(root, "selectionchange", recompute.bind(this, root), true);
+}
+
+function recompute(root: Node): void {
+    recompute.dn = FunctionNames.SelectionRecompute;
+    let doc = root.nodeType === Node.DOCUMENT_NODE ? root as Document : document;
+    let current = doc.getSelection();
+
+    // Bail out if we don't have a valid selection
+    if (current === null) { return; }
+
+    // Bail out if we got a valid selection but not valid nodes
+    // In Edge, selectionchange gets fired even on interactions like right clicks and
+    // can result in null anchorNode and focusNode if there was no previous selection on page
+    // Also, ignore any selections that start and end at the exact same point
+    if ((current.anchorNode === null && current.focusNode === null) ||
+        (current.anchorNode === current.focusNode && current.anchorOffset === current.focusOffset)) {
+        return;
+    }
+    let startNode = data.start ? data.start : null;
+    if (previous !== null && data.start !== null && startNode !== current.anchorNode) {
+        clearTimeout(timeout);
+        process(Event.Selection);
+    }
+
+    data = {
+        start: current.anchorNode,
+        startOffset: current.anchorOffset,
+        end: current.focusNode,
+        endOffset: current.focusOffset
+    };
+    previous = current;
+
+    clearTimeout(timeout);
+    timeout = setTimeout(process, Setting.LookAhead, Event.Selection);
+}
+
+function process(event: Event): void {
+    schedule(encode.bind(this, event));
+}
+
+export function reset(): void {
+    previous = null;
+    data = { start: 0, startOffset: 0, end: 0, endOffset: 0 };
+}
+
+export function stop(): void {
+    reset();
+    clearTimeout(timeout);
+}

package/src/interaction/submit.ts

@@ -1,32 +1,32 @@
-import { Event } from "@clarity-types/data";
-import { SubmitState } from "@clarity-types/interaction";
-import { FunctionNames } from "@clarity-types/performance";
-import { bind } from "@src/core/event";
-import { schedule } from "@src/core/task";
-import { time } from "@src/core/time";
-import encode from "./encode";
-import { target } from "@src/layout/target";
-
-export let state: SubmitState[] = [];
-
-export function start(): void {
-    reset();
-}
-
-export function observe(root: Node): void {
-    bind(root, "submit", recompute, true);
-}
-
-function recompute(evt: UIEvent): void {
-    recompute.dn = FunctionNames.SubmitRecompute;
-    state.push({ time: time(evt), event: Event.Submit, data: { target: target(evt) } });
-    schedule(encode.bind(this, Event.Submit));
-}
-
-export function reset(): void {
-    state = [];
-}
-
-export function stop(): void {
-    reset();
-}
+import { Event } from "@clarity-types/data";
+import { SubmitState } from "@clarity-types/interaction";
+import { FunctionNames } from "@clarity-types/performance";
+import { bind } from "@src/core/event";
+import { schedule } from "@src/core/task";
+import { time } from "@src/core/time";
+import encode from "./encode";
+import { target } from "@src/layout/target";
+
+export let state: SubmitState[] = [];
+
+export function start(): void {
+    reset();
+}
+
+export function observe(root: Node): void {
+    bind(root, "submit", recompute, true);
+}
+
+function recompute(evt: UIEvent): void {
+    recompute.dn = FunctionNames.SubmitRecompute;
+    state.push({ time: time(evt), event: Event.Submit, data: { target: target(evt) } });
+    schedule(encode.bind(this, Event.Submit));
+}
+
+export function reset(): void {
+    state = [];
+}
+
+export function stop(): void {
+    reset();
+}

package/src/interaction/timeline.ts

@@ -1,65 +1,65 @@
-import { BooleanFlag, Event } from "@clarity-types/data";
-import { BrowsingContext, Setting, TimelineState } from "@clarity-types/interaction";
-import * as baseline from "@src/data/baseline";
-import * as envelope from "@src/data/envelope";
-import encode from "@src/interaction/encode";
-
-let state: TimelineState[] = [];
-export let updates: TimelineState[] = [];
-
-export function start(): void {
-    state = [];
-    reset();
-}
-
-export function reset(): void {
-    updates = [];
-}
-
-export function track(time: number,
-    event: Event,
-    hash: string,
-    x: number,
-    y: number,
-    reaction: number = BooleanFlag.True,
-    context: number = BrowsingContext.Self): void {
-    state.push({
-        time,
-        event: Event.Timeline,
-        data: {
-            type: event,
-            hash,
-            x,
-            y,
-            reaction,
-            context
-        }
-    });
-
-    // Since timeline only keeps the data for configured time, we still want to continue tracking these values
-    // as part of the baseline. For instance, in a scenario where last scroll happened 5s ago.
-    // We would still need to capture the last scroll position as part of the baseline event, even when timeline will be empty.
-    baseline.track(event, x, y, time);
-}
-
-export function compute(): void {
-    const temp = [];
-    updates = [];
-    let max = envelope.data.start + envelope.data.duration;
-    let min = Math.max(max - Setting.TimelineSpan, 0);
-
-    for (let s of state) {
-        if (s.time >= min) {
-            if (s.time <= max) { updates.push(s); }
-            temp.push(s);
-        }
-    }
-
-    state = temp; // Drop events less than the min time
-    encode(Event.Timeline);
-}
-
-export function stop(): void {
-    state = [];
-    reset();
-}
+import { BooleanFlag, Event } from "@clarity-types/data";
+import { BrowsingContext, Setting, TimelineState } from "@clarity-types/interaction";
+import * as baseline from "@src/data/baseline";
+import * as envelope from "@src/data/envelope";
+import encode from "@src/interaction/encode";
+
+let state: TimelineState[] = [];
+export let updates: TimelineState[] = [];
+
+export function start(): void {
+    state = [];
+    reset();
+}
+
+export function reset(): void {
+    updates = [];
+}
+
+export function track(time: number,
+    event: Event,
+    hash: string,
+    x: number,
+    y: number,
+    reaction: number = BooleanFlag.True,
+    context: number = BrowsingContext.Self): void {
+    state.push({
+        time,
+        event: Event.Timeline,
+        data: {
+            type: event,
+            hash,
+            x,
+            y,
+            reaction,
+            context
+        }
+    });
+
+    // Since timeline only keeps the data for configured time, we still want to continue tracking these values
+    // as part of the baseline. For instance, in a scenario where last scroll happened 5s ago.
+    // We would still need to capture the last scroll position as part of the baseline event, even when timeline will be empty.
+    baseline.track(event, x, y, time);
+}
+
+export function compute(): void {
+    const temp = [];
+    updates = [];
+    let max = envelope.data.start + envelope.data.duration;
+    let min = Math.max(max - Setting.TimelineSpan, 0);
+
+    for (let s of state) {
+        if (s.time >= min) {
+            if (s.time <= max) { updates.push(s); }
+            temp.push(s);
+        }
+    }
+
+    state = temp; // Drop events less than the min time
+    encode(Event.Timeline);
+}
+
+export function stop(): void {
+    state = [];
+    reset();
+}

package/src/interaction/unload.ts

@@ -1,28 +1,28 @@
-import { BooleanFlag, Event } from "@clarity-types/data";
-import { UnloadData } from "@clarity-types/interaction";
-import { FunctionNames } from "@clarity-types/performance";
-import * as clarity from "@src/clarity";
-import { bind } from "@src/core/event";
-import { time } from "@src/core/time";
-import encode from "./encode";
-
-export let data: UnloadData;
-
-export function start(): void {
-    bind(window, "pagehide", recompute);
-}
-
-function recompute(evt: PageTransitionEvent): void {
-    recompute.dn = FunctionNames.UnloadRecompute;
-    data = { name: evt.type, persisted: evt.persisted ? BooleanFlag.True : BooleanFlag.False };
-    encode(Event.Unload, time(evt));
-    clarity.stop();
-}
-
-export function reset(): void {
-    data = null;
-}
-
-export function stop(): void {
-    reset();
-}
+import { BooleanFlag, Event } from "@clarity-types/data";
+import { UnloadData } from "@clarity-types/interaction";
+import { FunctionNames } from "@clarity-types/performance";
+import * as clarity from "@src/clarity";
+import { bind } from "@src/core/event";
+import { time } from "@src/core/time";
+import encode from "./encode";
+
+export let data: UnloadData;
+
+export function start(): void {
+    bind(window, "pagehide", recompute);
+}
+
+function recompute(evt: PageTransitionEvent): void {
+    recompute.dn = FunctionNames.UnloadRecompute;
+    data = { name: evt.type, persisted: evt.persisted ? BooleanFlag.True : BooleanFlag.False };
+    encode(Event.Unload, time(evt));
+    clarity.stop();
+}
+
+export function reset(): void {
+    data = null;
+}
+
+export function stop(): void {
+    reset();
+}

package/src/interaction/visibility.ts

@@ -1,27 +1,27 @@
-import { Event } from "@clarity-types/data";
-import { VisibilityData } from "@clarity-types/interaction";
-import { FunctionNames } from "@clarity-types/performance";
-import { bind } from "@src/core/event";
-import { time } from "@src/core/time";
-import encode from "./encode";
-
-export let data: VisibilityData;
-
-export function start(): void {
-    bind(document, "visibilitychange", recompute);
-    recompute();
-}
-
-function recompute(evt: UIEvent = null): void {
-    recompute.dn = FunctionNames.VisibilityRecompute;
-    data = { visible: "visibilityState" in document ? document.visibilityState : "default" };
-    encode(Event.Visibility, time(evt));
-}
-
-export function reset(): void {
-    data = null;
-}
-
-export function stop(): void {
-    reset();
+import { Event } from "@clarity-types/data";
+import { VisibilityData } from "@clarity-types/interaction";
+import { FunctionNames } from "@clarity-types/performance";
+import { bind } from "@src/core/event";
+import { time } from "@src/core/time";
+import encode from "./encode";
+
+export let data: VisibilityData;
+
+export function start(): void {
+    bind(document, "visibilitychange", recompute);
+    recompute();
+}
+
+function recompute(evt: UIEvent = null): void {
+    recompute.dn = FunctionNames.VisibilityRecompute;
+    data = { visible: "visibilityState" in document ? document.visibilityState : "default" };
+    encode(Event.Visibility, time(evt));
+}
+
+export function reset(): void {
+    data = null;
+}
+
+export function stop(): void {
+    reset();
 }