@kubesense/kubesense-browser-rum-core 1.0.0

package/cjs/browser/locationChangeObservable.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocationChangeObservable = createLocationChangeObservable;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+function createLocationChangeObservable(configuration, location) {
+    let currentLocation = (0, kubesense_browser_core_1.shallowClone)(location);
+    return new kubesense_browser_core_1.Observable((observable) => {
+        const { stop: stopHistoryTracking } = trackHistory(configuration, onLocationChange);
+        const { stop: stopHashTracking } = trackHash(configuration, onLocationChange);
+        function onLocationChange() {
+            if (currentLocation.href === location.href) {
+                return;
+            }
+            const newLocation = (0, kubesense_browser_core_1.shallowClone)(location);
+            observable.notify({
+                newLocation,
+                oldLocation: currentLocation,
+            });
+            currentLocation = newLocation;
+        }
+        return () => {
+            stopHistoryTracking();
+            stopHashTracking();
+        };
+    });
+}
+function trackHistory(configuration, onHistoryChange) {
+    const { stop: stopInstrumentingPushState } = (0, kubesense_browser_core_1.instrumentMethod)(getHistoryInstrumentationTarget('pushState'), 'pushState', ({ onPostCall }) => {
+        onPostCall(onHistoryChange);
+    });
+    const { stop: stopInstrumentingReplaceState } = (0, kubesense_browser_core_1.instrumentMethod)(getHistoryInstrumentationTarget('replaceState'), 'replaceState', ({ onPostCall }) => {
+        onPostCall(onHistoryChange);
+    });
+    const { stop: removeListener } = (0, kubesense_browser_core_1.addEventListener)(configuration, window, "popstate" /* DOM_EVENT.POP_STATE */, onHistoryChange);
+    return {
+        stop: () => {
+            stopInstrumentingPushState();
+            stopInstrumentingReplaceState();
+            removeListener();
+        },
+    };
+}
+function trackHash(configuration, onHashChange) {
+    return (0, kubesense_browser_core_1.addEventListener)(configuration, window, "hashchange" /* DOM_EVENT.HASH_CHANGE */, onHashChange);
+}
+function getHistoryInstrumentationTarget(methodName) {
+    // Ideally we should always instument the method on the prototype, however some frameworks (e.g [Next.js](https://github.com/vercel/next.js/blob/d3f5532065f3e3bb84fb54bd2dfd1a16d0f03a21/packages/next/src/client/components/app-router.tsx#L429))
+    // are wrapping the instance method. In that case we should also wrap the instance method.
+    return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype;
+}
+//# sourceMappingURL=locationChangeObservable.js.map

package/cjs/browser/locationChangeObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locationChangeObservable.js","sourceRoot":"","sources":["../../src/browser/locationChangeObservable.ts"],"names":[],"mappings":";;AAQA,wEAwBC;AAhCD,8EAA2H;AAQ3H,SAAgB,8BAA8B,CAAC,aAA+B,EAAE,QAAkB;IAChG,IAAI,eAAe,GAAG,IAAA,qCAAY,EAAC,QAAQ,CAAC,CAAA;IAE5C,OAAO,IAAI,mCAAU,CAAiB,CAAC,UAAU,EAAE,EAAE;QACnD,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,GAAG,YAAY,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAA;QACnF,MAAM,EAAE,IAAI,EAAE,gBAAgB,EAAE,GAAG,SAAS,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAA;QAE7E,SAAS,gBAAgB;YACvB,IAAI,eAAe,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAC3C,OAAM;YACR,CAAC;YACD,MAAM,WAAW,GAAG,IAAA,qCAAY,EAAC,QAAQ,CAAC,CAAA;YAC1C,UAAU,CAAC,MAAM,CAAC;gBAChB,WAAW;gBACX,WAAW,EAAE,eAAe;aAC7B,CAAC,CAAA;YACF,eAAe,GAAG,WAAW,CAAA;QAC/B,CAAC;QAED,OAAO,GAAG,EAAE;YACV,mBAAmB,EAAE,CAAA;YACrB,gBAAgB,EAAE,CAAA;QACpB,CAAC,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,aAA+B,EAAE,eAA2B;IAChF,MAAM,EAAE,IAAI,EAAE,0BAA0B,EAAE,GAAG,IAAA,yCAAgB,EAC3D,+BAA+B,CAAC,WAAW,CAAC,EAC5C,WAAW,EACX,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;QACjB,UAAU,CAAC,eAAe,CAAC,CAAA;IAC7B,CAAC,CACF,CAAA;IACD,MAAM,EAAE,IAAI,EAAE,6BAA6B,EAAE,GAAG,IAAA,yCAAgB,EAC9D,+BAA+B,CAAC,cAAc,CAAC,EAC/C,cAAc,EACd,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;QACjB,UAAU,CAAC,eAAe,CAAC,CAAA;IAC7B,CAAC,CACF,CAAA;IACD,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,IAAA,yCAAgB,EAAC,aAAa,EAAE,MAAM,wCAAuB,eAAe,CAAC,CAAA;IAE9G,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,0BAA0B,EAAE,CAAA;YAC5B,6BAA6B,EAAE,CAAA;YAC/B,cAAc,EAAE,CAAA;QAClB,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,SAAS,CAAC,aAA+B,EAAE,YAAwB;IAC1E,OAAO,IAAA,yCAAgB,EAAC,aAAa,EAAE,MAAM,4CAAyB,YAAY,CAAC,CAAA;AACrF,CAAC;AAED,SAAS,+BAA+B,CAAC,UAAwC;IAC/E,mPAAmP;IACnP,0FAA0F;IAC1F,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAA;AAChG,CAAC"}

package/cjs/browser/performanceObservable.d.ts

@@ -0,0 +1,174 @@
+import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core';
+import { Observable } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../domain/configuration';
+type RumPerformanceObserverConstructor = new (callback: PerformanceObserverCallback) => RumPerformanceObserver;
+export interface BrowserWindow extends Window {
+    PerformanceObserver: RumPerformanceObserverConstructor;
+    performance: Performance & {
+        interactionCount?: number;
+    };
+}
+export interface RumPerformanceObserver extends PerformanceObserver {
+    observe(options?: PerformanceObserverInit & {
+        durationThreshold?: number;
+    }): void;
+}
+export declare enum RumPerformanceEntryType {
+    EVENT = "event",
+    FIRST_INPUT = "first-input",
+    LARGEST_CONTENTFUL_PAINT = "largest-contentful-paint",
+    LAYOUT_SHIFT = "layout-shift",
+    LONG_TASK = "longtask",
+    LONG_ANIMATION_FRAME = "long-animation-frame",
+    NAVIGATION = "navigation",
+    PAINT = "paint",
+    RESOURCE = "resource",
+    VISIBILITY_STATE = "visibility-state"
+}
+export interface RumPerformanceLongTaskTiming {
+    name: string;
+    entryType: RumPerformanceEntryType.LONG_TASK;
+    startTime: RelativeTime;
+    duration: Duration;
+    toJSON(): Omit<PerformanceEntry, 'toJSON'>;
+}
+export interface RumPerformanceResourceTiming {
+    entryType: RumPerformanceEntryType.RESOURCE;
+    initiatorType: string;
+    responseStatus?: number;
+    name: string;
+    startTime: RelativeTime;
+    duration: Duration;
+    fetchStart: RelativeTime;
+    workerStart: RelativeTime;
+    domainLookupStart: RelativeTime;
+    domainLookupEnd: RelativeTime;
+    connectStart: RelativeTime;
+    secureConnectionStart: RelativeTime;
+    connectEnd: RelativeTime;
+    requestStart: RelativeTime;
+    responseStart: RelativeTime;
+    responseEnd: RelativeTime;
+    redirectStart: RelativeTime;
+    redirectEnd: RelativeTime;
+    decodedBodySize?: number;
+    encodedBodySize?: number;
+    transferSize?: number;
+    nextHopProtocol?: string;
+    renderBlockingStatus?: string;
+    traceId?: string;
+    deliveryType?: 'cache' | 'navigational-prefetch' | '';
+    toJSON(): Omit<PerformanceEntry, 'toJSON'>;
+}
+export interface RumPerformancePaintTiming {
+    entryType: RumPerformanceEntryType.PAINT;
+    name: 'first-paint' | 'first-contentful-paint';
+    startTime: RelativeTime;
+    toJSON(): Omit<RumPerformancePaintTiming, 'toJSON'>;
+}
+export interface RumPerformanceNavigationTiming extends Omit<RumPerformanceResourceTiming, 'entryType'> {
+    entryType: RumPerformanceEntryType.NAVIGATION;
+    initiatorType: 'navigation';
+    name: string;
+    domComplete: RelativeTime;
+    domContentLoadedEventEnd: RelativeTime;
+    domInteractive: RelativeTime;
+    loadEventEnd: RelativeTime;
+    toJSON(): Omit<RumPerformanceNavigationTiming, 'toJSON'>;
+}
+export interface RumLargestContentfulPaintTiming {
+    entryType: RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT;
+    startTime: RelativeTime;
+    size: number;
+    element?: Element;
+    url?: string;
+    toJSON(): Omit<RumLargestContentfulPaintTiming, 'toJSON'>;
+}
+export interface RumFirstInputTiming {
+    entryType: RumPerformanceEntryType.FIRST_INPUT;
+    startTime: RelativeTime;
+    processingStart: RelativeTime;
+    processingEnd: RelativeTime;
+    duration: Duration;
+    target?: Node;
+    interactionId?: number;
+    toJSON(): Omit<RumFirstInputTiming, 'toJSON'>;
+}
+export interface RumPerformanceEventTiming {
+    entryType: RumPerformanceEntryType.EVENT;
+    startTime: RelativeTime;
+    processingStart: RelativeTime;
+    processingEnd: RelativeTime;
+    duration: Duration;
+    interactionId?: number;
+    target?: Node;
+    name: string;
+    toJSON(): Omit<RumPerformanceEventTiming, 'toJSON'>;
+}
+export interface RumLayoutShiftAttribution {
+    node: Node | null;
+    previousRect: DOMRectReadOnly;
+    currentRect: DOMRectReadOnly;
+}
+export interface RumLayoutShiftTiming {
+    entryType: RumPerformanceEntryType.LAYOUT_SHIFT;
+    startTime: RelativeTime;
+    value: number;
+    hadRecentInput: boolean;
+    sources: RumLayoutShiftAttribution[];
+    toJSON(): Omit<RumLayoutShiftTiming, 'toJSON'>;
+}
+export interface RumPerformanceScriptTiming {
+    duration: Duration;
+    entryType: 'script';
+    executionStart: RelativeTime;
+    forcedStyleAndLayoutDuration: Duration;
+    invoker: string;
+    invokerType: 'user-callback' | 'event-listener' | 'resolve-promise' | 'reject-promise' | 'classic-script' | 'module-script';
+    name: 'script';
+    pauseDuration: Duration;
+    sourceCharPosition: number;
+    sourceFunctionName: string;
+    sourceURL: string;
+    startTime: RelativeTime;
+    window: Window;
+    windowAttribution: string;
+}
+export interface RumPerformanceLongAnimationFrameTiming {
+    blockingDuration: Duration;
+    duration: Duration;
+    entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME;
+    firstUIEventTimestamp: RelativeTime;
+    name: 'long-animation-frame';
+    renderStart: RelativeTime;
+    scripts: RumPerformanceScriptTiming[];
+    startTime: RelativeTime;
+    styleAndLayoutStart: RelativeTime;
+    toJSON(): Omit<RumPerformanceLongAnimationFrameTiming, 'toJSON'>;
+}
+export interface RumFirstHiddenTiming {
+    entryType: RumPerformanceEntryType.VISIBILITY_STATE;
+    name: 'hidden' | 'visible';
+    startTime: RelativeTime;
+    toJSON(): Omit<RumFirstHiddenTiming, 'toJSON'>;
+}
+export type RumPerformanceEntry = RumPerformanceResourceTiming | RumPerformanceLongTaskTiming | RumPerformanceLongAnimationFrameTiming | RumPerformancePaintTiming | RumPerformanceNavigationTiming | RumLargestContentfulPaintTiming | RumFirstInputTiming | RumPerformanceEventTiming | RumLayoutShiftTiming | RumFirstHiddenTiming;
+export interface EntryTypeToReturnType {
+    [RumPerformanceEntryType.EVENT]: RumPerformanceEventTiming;
+    [RumPerformanceEntryType.FIRST_INPUT]: RumFirstInputTiming;
+    [RumPerformanceEntryType.LARGEST_CONTENTFUL_PAINT]: RumLargestContentfulPaintTiming;
+    [RumPerformanceEntryType.LAYOUT_SHIFT]: RumLayoutShiftTiming;
+    [RumPerformanceEntryType.PAINT]: RumPerformancePaintTiming;
+    [RumPerformanceEntryType.LONG_TASK]: RumPerformanceLongTaskTiming;
+    [RumPerformanceEntryType.LONG_ANIMATION_FRAME]: RumPerformanceLongAnimationFrameTiming;
+    [RumPerformanceEntryType.NAVIGATION]: RumPerformanceNavigationTiming;
+    [RumPerformanceEntryType.RESOURCE]: RumPerformanceResourceTiming;
+    [RumPerformanceEntryType.VISIBILITY_STATE]: RumFirstHiddenTiming;
+}
+export declare function createPerformanceObservable<T extends RumPerformanceEntryType>(configuration: RumConfiguration, options: {
+    type: T;
+    buffered?: boolean;
+    durationThreshold?: number;
+}): Observable<EntryTypeToReturnType[T][]>;
+export declare function supportPerformanceTimingEvent(entryType: RumPerformanceEntryType): boolean;
+export {};

package/cjs/browser/performanceObservable.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RumPerformanceEntryType = void 0;
+exports.createPerformanceObservable = createPerformanceObservable;
+exports.supportPerformanceTimingEvent = supportPerformanceTimingEvent;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const resourceUtils_1 = require("../domain/resource/resourceUtils");
+const firstInputPolyfill_1 = require("./firstInputPolyfill");
+// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary
+// string is an expected performance entry
+// eslint-disable-next-line no-restricted-syntax
+var RumPerformanceEntryType;
+(function (RumPerformanceEntryType) {
+    RumPerformanceEntryType["EVENT"] = "event";
+    RumPerformanceEntryType["FIRST_INPUT"] = "first-input";
+    RumPerformanceEntryType["LARGEST_CONTENTFUL_PAINT"] = "largest-contentful-paint";
+    RumPerformanceEntryType["LAYOUT_SHIFT"] = "layout-shift";
+    RumPerformanceEntryType["LONG_TASK"] = "longtask";
+    RumPerformanceEntryType["LONG_ANIMATION_FRAME"] = "long-animation-frame";
+    RumPerformanceEntryType["NAVIGATION"] = "navigation";
+    RumPerformanceEntryType["PAINT"] = "paint";
+    RumPerformanceEntryType["RESOURCE"] = "resource";
+    RumPerformanceEntryType["VISIBILITY_STATE"] = "visibility-state";
+})(RumPerformanceEntryType || (exports.RumPerformanceEntryType = RumPerformanceEntryType = {}));
+function createPerformanceObservable(configuration, options) {
+    return new kubesense_browser_core_1.Observable((observable) => {
+        if (!window.PerformanceObserver) {
+            return;
+        }
+        const handlePerformanceEntries = (entries) => {
+            const rumPerformanceEntries = filterRumPerformanceEntries(entries);
+            if (rumPerformanceEntries.length > 0) {
+                observable.notify(rumPerformanceEntries);
+            }
+        };
+        let timeoutId;
+        let isObserverInitializing = true;
+        const observer = new PerformanceObserver((0, kubesense_browser_core_1.monitor)((entries) => {
+            // In Safari the performance observer callback is synchronous.
+            // Because the buffered performance entry list can be quite large we delay the computation to prevent the SDK from blocking the main thread on init
+            if (isObserverInitializing) {
+                timeoutId = (0, kubesense_browser_core_1.setTimeout)(() => handlePerformanceEntries(entries.getEntries()));
+            }
+            else {
+                handlePerformanceEntries(entries.getEntries());
+            }
+        }));
+        try {
+            observer.observe(options);
+        }
+        catch (_a) {
+            // Some old browser versions (<= chrome 74 ) don't support the PerformanceObserver type and buffered options
+            // In these cases, fallback to getEntriesByType and PerformanceObserver with entryTypes
+            // TODO: remove this fallback in the next major version
+            const fallbackSupportedEntryTypes = [
+                RumPerformanceEntryType.RESOURCE,
+                RumPerformanceEntryType.NAVIGATION,
+                RumPerformanceEntryType.LONG_TASK,
+                RumPerformanceEntryType.PAINT,
+            ];
+            if (fallbackSupportedEntryTypes.includes(options.type)) {
+                if (options.buffered) {
+                    timeoutId = (0, kubesense_browser_core_1.setTimeout)(() => handlePerformanceEntries(performance.getEntriesByType(options.type)));
+                }
+                try {
+                    observer.observe({ entryTypes: [options.type] });
+                }
+                catch (_b) {
+                    // Old versions of Safari are throwing "entryTypes contained only unsupported types"
+                    // errors when observing only unsupported entry types.
+                    //
+                    // We could use `supportPerformanceTimingEvent` to make sure we don't invoke
+                    // `observer.observe` with an unsupported entry type, but Safari 11 and 12 don't support
+                    // `Performance.supportedEntryTypes`, so doing so would lose support for these versions
+                    // even if they do support the entry type.
+                    return;
+                }
+            }
+        }
+        isObserverInitializing = false;
+        manageResourceTimingBufferFull(configuration);
+        let stopFirstInputTiming;
+        if (!supportPerformanceTimingEvent(RumPerformanceEntryType.FIRST_INPUT) &&
+            options.type === RumPerformanceEntryType.FIRST_INPUT) {
+            ;
+            ({ stop: stopFirstInputTiming } = (0, firstInputPolyfill_1.retrieveFirstInputTiming)(configuration, (timing) => {
+                handlePerformanceEntries([timing]);
+            }));
+        }
+        return () => {
+            observer.disconnect();
+            if (stopFirstInputTiming) {
+                stopFirstInputTiming();
+            }
+            (0, kubesense_browser_core_1.clearTimeout)(timeoutId);
+        };
+    });
+}
+let resourceTimingBufferFullListener;
+function manageResourceTimingBufferFull(configuration) {
+    if (!resourceTimingBufferFullListener && supportPerformanceObject() && 'addEventListener' in performance) {
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377
+        resourceTimingBufferFullListener = (0, kubesense_browser_core_1.addEventListener)(configuration, performance, 'resourcetimingbufferfull', () => {
+            performance.clearResourceTimings();
+        });
+    }
+    return () => {
+        resourceTimingBufferFullListener === null || resourceTimingBufferFullListener === void 0 ? void 0 : resourceTimingBufferFullListener.stop();
+    };
+}
+function supportPerformanceObject() {
+    return window.performance !== undefined && 'getEntries' in performance;
+}
+function supportPerformanceTimingEvent(entryType) {
+    return (window.PerformanceObserver &&
+        PerformanceObserver.supportedEntryTypes !== undefined &&
+        PerformanceObserver.supportedEntryTypes.includes(entryType));
+}
+function filterRumPerformanceEntries(entries) {
+    return entries.filter((entry) => !isForbiddenResource(entry));
+}
+function isForbiddenResource(entry) {
+    return (entry.entryType === RumPerformanceEntryType.RESOURCE &&
+        (!(0, resourceUtils_1.isAllowedRequestUrl)(entry.name) || !(0, resourceUtils_1.hasValidResourceEntryDuration)(entry)));
+}
+//# sourceMappingURL=performanceObservable.js.map

package/cjs/browser/performanceObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObservable.js","sourceRoot":"","sources":["../../src/browser/performanceObservable.ts"],"names":[],"mappings":"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"}

package/cjs/browser/performanceUtils.d.ts

@@ -0,0 +1,7 @@
+import type { RelativeTime } from '@kubesense/kubesense-browser-core';
+import type { RumPerformanceNavigationTiming } from './performanceObservable';
+export declare function getNavigationEntry(): RumPerformanceNavigationTiming;
+export type TimingsFromDeprecatedPerformanceTiming = {
+    -readonly [key in keyof Omit<PerformanceTiming, 'toJSON'>]: RelativeTime;
+};
+export declare function computeTimingsFromDeprecatedPerformanceTiming(): TimingsFromDeprecatedPerformanceTiming;

package/cjs/browser/performanceUtils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNavigationEntry = getNavigationEntry;
+exports.computeTimingsFromDeprecatedPerformanceTiming = computeTimingsFromDeprecatedPerformanceTiming;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const performanceObservable_1 = require("./performanceObservable");
+function getNavigationEntry() {
+    if ((0, performanceObservable_1.supportPerformanceTimingEvent)(performanceObservable_1.RumPerformanceEntryType.NAVIGATION)) {
+        const navigationEntry = performance.getEntriesByType(performanceObservable_1.RumPerformanceEntryType.NAVIGATION)[0];
+        if (navigationEntry) {
+            return navigationEntry;
+        }
+    }
+    const timings = computeTimingsFromDeprecatedPerformanceTiming();
+    const entry = {
+        entryType: performanceObservable_1.RumPerformanceEntryType.NAVIGATION,
+        initiatorType: 'navigation',
+        name: window.location.href,
+        startTime: 0,
+        duration: timings.loadEventEnd,
+        decodedBodySize: 0,
+        encodedBodySize: 0,
+        transferSize: 0,
+        workerStart: 0,
+        toJSON: () => ({ ...entry, toJSON: undefined }),
+        ...timings,
+    };
+    return entry;
+}
+function computeTimingsFromDeprecatedPerformanceTiming() {
+    const result = {};
+    const timing = performance.timing;
+    for (const key in timing) {
+        if ((0, kubesense_browser_core_1.isNumber)(timing[key])) {
+            const numberKey = key;
+            const timingElement = timing[numberKey];
+            result[numberKey] = timingElement === 0 ? 0 : (0, kubesense_browser_core_1.getRelativeTime)(timingElement);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=performanceUtils.js.map

package/cjs/browser/performanceUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceUtils.js","sourceRoot":"","sources":["../../src/browser/performanceUtils.ts"],"names":[],"mappings":";;AAKA,gDA0BC;AAMD,sGAYC;AAhDD,8EAA6E;AAE7E,mEAAgG;AAEhG,SAAgB,kBAAkB;IAChC,IAAI,IAAA,qDAA6B,EAAC,+CAAuB,CAAC,UAAU,CAAC,EAAE,CAAC;QACtE,MAAM,eAAe,GAAG,WAAW,CAAC,gBAAgB,CAClD,+CAAuB,CAAC,UAAU,CACnC,CAAC,CAAC,CAA8C,CAAA;QACjD,IAAI,eAAe,EAAE,CAAC;YACpB,OAAO,eAAe,CAAA;QACxB,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAAG,6CAA6C,EAAE,CAAA;IAC/D,MAAM,KAAK,GAAmC;QAC5C,SAAS,EAAE,+CAAuB,CAAC,UAAmB;QACtD,aAAa,EAAE,YAAqB;QACpC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI;QAC1B,SAAS,EAAE,CAAiB;QAC5B,QAAQ,EAAE,OAAO,CAAC,YAAY;QAC9B,eAAe,EAAE,CAAC;QAClB,eAAe,EAAE,CAAC;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,CAAiB;QAC9B,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAC/C,GAAG,OAAO;KACX,CAAA;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAMD,SAAgB,6CAA6C;IAC3D,MAAM,MAAM,GAAoD,EAAE,CAAA;IAClE,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAA;IAEjC,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,IAAI,IAAA,iCAAQ,EAAC,MAAM,CAAC,GAA8B,CAAC,CAAC,EAAE,CAAC;YACrD,MAAM,SAAS,GAAG,GAAmD,CAAA;YACrE,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,CAAc,CAAA;YACpD,MAAM,CAAC,SAAS,CAAC,GAAG,aAAa,KAAK,CAAC,CAAC,CAAC,CAAE,CAAkB,CAAC,CAAC,CAAC,IAAA,wCAAe,EAAC,aAAa,CAAC,CAAA;QAChG,CAAC;IACH,CAAC;IACD,OAAO,MAAgD,CAAA;AACzD,CAAC"}

package/cjs/browser/scroll.d.ts

@@ -0,0 +1,2 @@
+export declare function getScrollX(): number;
+export declare function getScrollY(): number;

package/cjs/browser/scroll.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScrollX = getScrollX;
+exports.getScrollY = getScrollY;
+function getScrollX() {
+    let scrollX;
+    const visual = window.visualViewport;
+    if (visual) {
+        scrollX = visual.pageLeft - visual.offsetLeft;
+    }
+    else if (window.scrollX !== undefined) {
+        scrollX = window.scrollX;
+    }
+    else {
+        scrollX = window.pageXOffset || 0;
+    }
+    return Math.round(scrollX);
+}
+function getScrollY() {
+    let scrollY;
+    const visual = window.visualViewport;
+    if (visual) {
+        scrollY = visual.pageTop - visual.offsetTop;
+    }
+    else if (window.scrollY !== undefined) {
+        scrollY = window.scrollY;
+    }
+    else {
+        scrollY = window.pageYOffset || 0;
+    }
+    return Math.round(scrollY);
+}
+//# sourceMappingURL=scroll.js.map

package/cjs/browser/scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.js","sourceRoot":"","sources":["../../src/browser/scroll.ts"],"names":[],"mappings":";;AAAA,gCAWC;AAED,gCAWC;AAxBD,SAAgB,UAAU;IACxB,IAAI,OAAO,CAAA;IACX,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAA;IACpC,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,GAAG,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAA;IAC/C,CAAC;SAAM,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACxC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAA;IAC1B,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,CAAA;IACnC,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;AAC5B,CAAC;AAED,SAAgB,UAAU;IACxB,IAAI,OAAO,CAAA;IACX,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAA;IACpC,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,GAAG,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,SAAS,CAAA;IAC7C,CAAC;SAAM,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACxC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAA;IAC1B,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,MAAM,CAAC,WAAW,IAAI,CAAC,CAAA;IACnC,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;AAC5B,CAAC"}

package/cjs/browser/viewportObservable.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from '@kubesense/kubesense-browser-core';
+import type { RumConfiguration } from '../domain/configuration';
+export interface ViewportDimension {
+    height: number;
+    width: number;
+    [k: string]: unknown;
+}
+export declare function initViewportObservable(configuration: RumConfiguration): Observable<ViewportDimension>;
+export declare function createViewportObservable(configuration: RumConfiguration): Observable<ViewportDimension>;
+export declare function getViewportDimension(): ViewportDimension;

package/cjs/browser/viewportObservable.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initViewportObservable = initViewportObservable;
+exports.createViewportObservable = createViewportObservable;
+exports.getViewportDimension = getViewportDimension;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+let viewportObservable;
+function initViewportObservable(configuration) {
+    if (!viewportObservable) {
+        viewportObservable = createViewportObservable(configuration);
+    }
+    return viewportObservable;
+}
+function createViewportObservable(configuration) {
+    return new kubesense_browser_core_1.Observable((observable) => {
+        const { throttled: updateDimension } = (0, kubesense_browser_core_1.throttle)(() => {
+            observable.notify(getViewportDimension());
+        }, 200);
+        return (0, kubesense_browser_core_1.addEventListener)(configuration, window, "resize" /* DOM_EVENT.RESIZE */, updateDimension, { capture: true, passive: true })
+            .stop;
+    });
+}
+// excludes the width and height of any rendered classic scrollbar that is fixed to the visual viewport
+function getViewportDimension() {
+    const visual = window.visualViewport;
+    if (visual) {
+        return {
+            width: Number(visual.width * visual.scale),
+            height: Number(visual.height * visual.scale),
+        };
+    }
+    return {
+        width: Number(window.innerWidth || 0),
+        height: Number(window.innerHeight || 0),
+    };
+}
+//# sourceMappingURL=viewportObservable.js.map

package/cjs/browser/viewportObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewportObservable.js","sourceRoot":"","sources":["../../src/browser/viewportObservable.ts"],"names":[],"mappings":";;AAWA,wDAKC;AAED,4DASC;AAGD,oDAaC;AA3CD,8EAAqG;AASrG,IAAI,kBAA6D,CAAA;AAEjE,SAAgB,sBAAsB,CAAC,aAA+B;IACpE,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACxB,kBAAkB,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAA;IAC9D,CAAC;IACD,OAAO,kBAAkB,CAAA;AAC3B,CAAC;AAED,SAAgB,wBAAwB,CAAC,aAA+B;IACtE,OAAO,IAAI,mCAAU,CAAoB,CAAC,UAAU,EAAE,EAAE;QACtD,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,IAAA,iCAAQ,EAAC,GAAG,EAAE;YACnD,UAAU,CAAC,MAAM,CAAC,oBAAoB,EAAE,CAAC,CAAA;QAC3C,CAAC,EAAE,GAAG,CAAC,CAAA;QAEP,OAAO,IAAA,yCAAgB,EAAC,aAAa,EAAE,MAAM,mCAAoB,eAAe,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;aAChH,IAAI,CAAA;IACT,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,uGAAuG;AACvG,SAAgB,oBAAoB;IAClC,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAA;IACpC,IAAI,MAAM,EAAE,CAAC;QACX,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YAC1C,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC;SAC7C,CAAA;IACH,CAAC;IAED,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;QACrC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC;KACxC,CAAA;AACH,CAAC"}

package/cjs/browser/windowOpenObservable.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from '@kubesense/kubesense-browser-core';
+export declare function createWindowOpenObservable(): {
+    observable: Observable<void>;
+    stop: typeof import("@kubesense/kubesense-browser-core").noop;
+};

package/cjs/browser/windowOpenObservable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWindowOpenObservable = createWindowOpenObservable;
+const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+function createWindowOpenObservable() {
+    const observable = new kubesense_browser_core_1.Observable();
+    const { stop } = (0, kubesense_browser_core_1.instrumentMethod)(window, 'open', () => observable.notify());
+    return { observable, stop };
+}
+//# sourceMappingURL=windowOpenObservable.js.map

package/cjs/browser/windowOpenObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"windowOpenObservable.js","sourceRoot":"","sources":["../../src/browser/windowOpenObservable.ts"],"names":[],"mappings":";;AAEA,gEAIC;AAND,8EAAgF;AAEhF,SAAgB,0BAA0B;IACxC,MAAM,UAAU,GAAG,IAAI,mCAAU,EAAQ,CAAA;IACzC,MAAM,EAAE,IAAI,EAAE,GAAG,IAAA,yCAAgB,EAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAA;IAC5E,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,CAAA;AAC7B,CAAC"}

package/cjs/domain/action/actionCollection.d.ts

@@ -0,0 +1,21 @@
+import type { ClocksState, Context, Observable } from '@kubesense/kubesense-browser-core';
+import { ActionType } from '../../rawRumEvent.types';
+import type { LifeCycle } from '../lifeCycle';
+import type { RumConfiguration } from '../configuration';
+import type { Hooks } from '../hooks';
+import type { RumMutationRecord } from '../../browser/domMutationObservable';
+import type { ActionContexts, ClickAction } from './trackClickActions';
+export type { ActionContexts };
+export interface CustomAction {
+    type: typeof ActionType.CUSTOM;
+    name: string;
+    startClocks: ClocksState;
+    context?: Context;
+    handlingStack?: string;
+}
+export type AutoAction = ClickAction;
+export declare function startActionCollection(lifeCycle: LifeCycle, hooks: Hooks, domMutationObservable: Observable<RumMutationRecord[]>, windowOpenObservable: Observable<void>, configuration: RumConfiguration): {
+    addAction: (action: CustomAction) => void;
+    actionContexts: ActionContexts;
+    stop: () => void;
+};