@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/types/builders/objects/objects-anonymous-node.d.ts

@@ -0,0 +1,52 @@
+import type { AnonymousTrackerEventInput } from '../events-anonymous-node';
+type PageInput = {
+    id?: string;
+    type?: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * @typedef AnonymousObjectInput
+ * Object input
+ *
+ * The root object should at least an `id` and `type`. The object will be passed
+ * as-if if those two fields are missing.
+ *
+ * Any field containing an object or array will be formatted recursively.
+ *
+ * Example object:
+
+ * ```
+ * {
+ * type: 'Listing',
+ * id: 'search-query',
+ * items: [{
+ * type: 'ClassifiedAd',
+ * id: 'ad-123'
+ * }]
+ *}
+ *```
+ */
+export type AnonymousObjectInput = {
+    id?: string;
+    type?: string;
+    item?: AnonymousObjectInput;
+    items?: Array<AnonymousObjectInput>;
+    page?: PageInput;
+    custom: never;
+    'spt:custom': never;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Format object.
+ *
+ * This function will recursively format itself and all nested object.
+ * The initialPage parameter is optional and will be used in the recursive
+ * nature to always pass in the root object page to each formatting.
+ *
+ * @private
+ * @param {object} input
+ * @param {object|undefined} pageInput Optional
+ */
+export declare const formatObject: (input: Pick<AnonymousTrackerEventInput, "object">, pageInput?: PageInput) => Record<string, unknown> | undefined;
+export default formatObject;
+export declare const defaultValue: () => undefined;

package/dist/types/builders/objects/objects-anonymous.d.ts

@@ -0,0 +1,2 @@
+export * from './objects-anonymous-node';
+export { default } from './objects-anonymous-node';

package/dist/types/builders/objects/objects-browser.d.ts

@@ -0,0 +1,11 @@
+export * from './objects-node';
+export { default } from './objects-node';
+export declare const defaultValue: () => {
+    name?: undefined;
+    url?: undefined;
+    id?: undefined;
+} | {
+    name: string;
+    url: string | undefined;
+    id: string | undefined;
+};

package/dist/types/builders/objects/objects-node.d.ts

@@ -0,0 +1,60 @@
+import type { TrackerEventInput } from '../events';
+/**
+ * Minimal set of page properties to derive other values, like @id.
+ */
+export type PageInput = {
+    id?: string;
+    type?: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Object input
+ *
+ * The root object should at least an `id` and `type`. The object will be passed
+ * as-if if those two fields are missing.
+ *
+ * Any field containing an object or array will be formatted recursively.
+ *
+ * Example object:
+ *
+ * ```js
+ * {
+ *   type: 'Listing',
+ *   id: 'search-query',
+ *   items: [{
+ *     type: 'ClassifiedAd',
+ *     id: 'ad-123'
+ *   }]
+ * }
+ *```
+ */
+export type ObjectInput = {
+    id?: string;
+    type?: string;
+    realm?: string;
+    custom?: Record<string, unknown>;
+    item?: ObjectInput;
+    items?: Array<ObjectInput>;
+    page?: PageInput;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Format object.
+ *
+ * This function will recursively format itself and all nested object.
+ * The initialPage parameter is optional and will be used in the recursive
+ * nature to always pass in the root object page to each formatting.
+ *
+ * @param input
+ * @param pageInput
+ * @private
+ */
+export declare const formatObject: (input: Pick<TrackerEventInput, "object">, pageInput?: PageInput) => Record<string, unknown> | undefined;
+/**
+ * @internal
+ */
+export default formatObject;
+/**
+ * @internal
+ */
+export declare const defaultValue: () => undefined;

package/dist/types/builders/objects/objects.d.ts

@@ -0,0 +1,2 @@
+export * from './objects-node';
+export { default } from './objects-node';

package/dist/types/builders/objects/utils.d.ts

@@ -0,0 +1 @@
+export declare function generateObjectSDRN(id?: string | number, providerId?: string, type?: string): string | number | undefined;

package/dist/types/builders/origin-browser.d.ts

@@ -0,0 +1,5 @@
+export * from './origin-node';
+export { default } from './origin-node';
+export declare const defaultValue: () => {
+    url: string;
+};

package/dist/types/builders/origin-node.d.ts

@@ -0,0 +1,18 @@
+import type { TrackerEventInput } from './events';
+/**
+ * @typedef OriginInput
+ */
+export type OriginInput = {
+    id?: string;
+    url?: string;
+    type?: string;
+    [k: string]: unknown | undefined;
+};
+export default function origin(input: Pick<TrackerEventInput, 'origin' | 'provider'>): {
+    '@type'?: string | undefined;
+    '@id'?: string | number | undefined;
+} & {
+    [k: string]: unknown;
+    url?: string;
+};
+export declare const defaultValue: () => undefined;

package/dist/types/builders/origin.d.ts

@@ -0,0 +1,2 @@
+export * from './origin-node';
+export { default } from './origin-node';

package/dist/types/builders/provider.d.ts

@@ -0,0 +1,14 @@
+import type { TrackerEventInput } from './events';
+export type ProviderInput = {
+    id: string;
+    type?: string;
+    [k: string]: unknown | undefined;
+};
+export type Provider = {
+    '@id': string;
+    '@type': string;
+    [k: string]: unknown | undefined;
+};
+export declare function generateProviderSDRN(providerId?: string): string;
+export default function provider(input?: Pick<TrackerEventInput, 'provider'>): Provider;
+export declare const defaultValue: () => undefined;

package/dist/types/builders/session-browser.d.ts

@@ -0,0 +1,20 @@
+import type { TrackerEventInput } from './events-node';
+export type Session = {
+    '@id': string;
+    startTime: string;
+};
+type StoredSession = {
+    id: string;
+    startTime: Date;
+    lastEventTime: Date;
+};
+type StoredSessionSerialized = [
+    id: string,
+    startTime: number,
+    lastEventTime: number
+];
+export declare const readAndParse: (storageKey: string) => StoredSessionSerialized | undefined;
+export declare const readSession: () => StoredSession | undefined;
+export declare const defaultValue: () => undefined;
+export default function session(_input?: TrackerEventInput, eventCreationDate?: Date): Session;
+export {};

package/dist/types/builders/session-node.d.ts

@@ -0,0 +1,3 @@
+import type { TrackerEventInput } from './events';
+export declare const defaultValue: () => undefined;
+export default function (input?: TrackerEventInput): TrackerEventInput;

package/dist/types/builders/session.d.ts

@@ -0,0 +1,2 @@
+export * from './session-browser';
+export { default } from './session-browser';

package/dist/types/builders/tracker-browser.d.ts

@@ -0,0 +1,2 @@
+export * from './tracker-node';
+export { default } from './tracker-node';

package/dist/types/builders/tracker-node.d.ts

@@ -0,0 +1,14 @@
+import type { TrackerEventInput } from './events';
+/** */
+export type TrackerInput = Record<string, unknown>;
+export type Tracker = {
+    name: string;
+    type: string;
+    version: string;
+    [k: string]: unknown | undefined;
+};
+/**
+ * Format tracker objects
+ */
+export default function tracker(input?: Pick<TrackerEventInput, 'tracker'>): Tracker;
+export declare const defaultValue: () => undefined;

package/dist/types/builders/trackerBuilder.d.ts

@@ -0,0 +1,2 @@
+export * from './tracker-node';
+export { default } from './tracker-node';

package/dist/types/config-browser.d.ts

@@ -0,0 +1,23 @@
+export declare const collectorEndpoints: {
+    dev: string;
+    pre: string;
+    pro: string;
+};
+export declare const CISEndpoints: {
+    dev: string;
+    pre: string;
+    pro: string;
+};
+export declare const remoteConfig: {
+    dev: string;
+    pre: string;
+    pro: string;
+};
+export declare const baseConfig: {
+    cisEnabled: boolean;
+    deployStage: string;
+    eventDebounce: number;
+    environment: string;
+    collectorPath: string;
+    useBeaconWhenAvailable: boolean;
+};

package/dist/types/config.d.ts

@@ -0,0 +1,6 @@
+export declare const baseConfig: {
+    eventDebounce: number;
+    environment: "node" | "browser";
+    cisEnabled: boolean;
+    collectorPath: string;
+};

package/dist/types/createPulseTracker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module createPulseTracker
+ * This module is part of the Pulse SDK implementation of Schibsted's Mandatory Building Blocks (MBB) specification.
+ * It is intended to simplify the creation and management of a singleton Pulse Tracker instance in browser environments.
+ * Note that this module should only be used in browser environments, as it relies on the global `window` object.
+ */
+import Tracker, { type Builders, type SDKConfigInput } from './Tracker';
+export interface IPulseTrackerCreateParams {
+    clientId: string;
+    config?: SDKConfigInput;
+    builders?: Builders;
+}
+/**
+ * Creates and returns the singleton Pulse Tracker instance.
+ * @param clientId
+ * @param config
+ * @param builders
+ * @throws - If called outside a browser environment.
+ * @throws - If the Pulse Tracker has already been created (or creation is already in progress).
+ */
+export declare function createPulseTracker({ clientId, config, builders }: IPulseTrackerCreateParams): Promise<Tracker>;

package/dist/types/defer.d.ts

@@ -0,0 +1,28 @@
+import type { EventInput } from './types';
+/**
+ * @public
+ * @typedef ResolvedInput
+ * A deferred EventInput can be resolved in a concrete PulseEvent object, a promise of one or the
+ * response of the network call to the Collector's endpoint.
+ */
+export type ResolvedInput = EventInput | PromiseLike<EventInput> | Response;
+/**
+ * @private
+ * @typedef PromiseResolver
+ * Defines possible inputs for resolving or rejecting a deferred EventInput.
+ */
+type PromiseResolver = (param: ResolvedInput) => void;
+/**
+ * @public
+ * @typedef Deferred
+ * Wraps the EventInput into a Promise, which has its resolve and reject callbacks externalized, so an
+ * outside scope can access them and postpone its resolution.
+ */
+export type Deferred = {
+    promise: Promise<ResolvedInput>;
+    resolve: PromiseResolver;
+    reject: PromiseResolver;
+    inputValue: EventInput | PromiseLike<EventInput>;
+};
+export default function (value: EventInput | PromiseLike<EventInput>): Deferred;
+export {};

package/dist/types/getPulseTracker.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module getPulseTracker
+ * This module is part of the Pulse SDK implementation of Schibsted's Mandatory Building Blocks (MBB) specification.
+ * It provides a function to retrieve the singleton Pulse Tracker instance in browser environments.
+ * Note that this module should only be used in browser environments, as it relies on the global `window` object.
+ *
+ * @privateRemarks
+ * For future contributors: This module is designed to work as lean as possible, avoiding dependencies on other
+ * parts of the SDK.
+ * This is to ensure that it can be safely imported and used in various contexts without introducing unnecessary
+ * submodules and package dependencies. Only types are imported from other parts of the SDK.
+ */
+import type { Tracker } from './index';
+type PulseTrackerReadyEventDetail = {
+    payload: {
+        tracker: Tracker;
+    };
+};
+type PulseTrackerReadyEvent = CustomEvent<PulseTrackerReadyEventDetail>;
+/**
+ * Event name dispatched when the Pulse Tracker instance is ready.
+ * It includes the "pulse:" namespace to avoid potential conflicts with other libraries.
+ */
+declare const PULSE_TRACKER_READY_EVENT = "pulse:tracker:ready";
+declare global {
+    interface Window {
+        __pulseTracker?: Promise<Tracker>;
+    }
+    interface WindowEventMap {
+        [PULSE_TRACKER_READY_EVENT]: PulseTrackerReadyEvent;
+    }
+}
+/**
+ * Returns the singleton Pulse Tracker instance.
+ * @throws - If the Pulse Tracker creation did not resolve within the timeout limit.
+ * @throws - If called outside a browser environment.
+ *
+ * @example
+ *
+ * ```ts
+ * import { getPulseTracker, type Tracker } from '@schibsted/pulse-sdk-js';
+ *
+ * let pulseTracker: Promise<Tracker>;
+ *
+ * try {
+ *  pulseTracker = await getPulseTracker();
+ * } catch(error) {
+ *   // not in browser environment
+ *   // or
+ *   // tracker not resolved within time limit
+ * }
+ *
+ * if (pulseTracker) {
+ *   pulseTracker.trackViewPage({ ... });
+ * }
+ * ```
+ */
+export declare function getPulseTracker(): Promise<Tracker>;
+export {};

package/dist/types/identity/actor.d.ts

@@ -0,0 +1,28 @@
+import type { ActorInput } from '../builders';
+import type { Builders } from '../Tracker';
+/**
+ * @internal exported for testing
+ */
+export declare const WARN_CIS_SYNC_LOGIN_UNDEFINED: string;
+/**
+ * Get the actor id (userId) from the current browser. A promise is returned
+ * because a call may be made to complete the login process.
+ *
+ * *Note*: This method will return a Promise that is always rejected on node
+ environments.
+ @category Identifiers
+ */
+declare const getUserId: (builders: Builders) => Promise<string | number | undefined>;
+/**
+ * @category Identifiers
+ */
+declare const getActor: (builders: Builders) => Promise<ActorInput>;
+declare const userIsLoggedIn: (builders: Builders) => Promise<boolean>;
+/**
+ * Evaluate actor input given to the sdk/this method and pass it through the
+ * Actor event formatter.
+ * @category Tracker
+ * @private
+ */
+declare const evaluateActor: (eventInput?: unknown, builders?: Builders) => Promise<ActorInput>;
+export { getUserId, getActor, userIsLoggedIn, evaluateActor };

package/dist/types/identity/advertising.d.ts

@@ -0,0 +1,30 @@
+import type { AdvertisingIdentifiers } from '@schibsted/pulse-cis-sync';
+import type { Builders, SDKState } from '../Tracker';
+/**
+ * Get the includeAdvertising flag, set on initialisation.
+ * @private
+ * @see constructor
+ * @category Identifiers
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ */
+declare const getIncludeAdvertising: (sdkState: SDKState) => boolean | Promise<boolean>;
+/**
+ * Get the advertisement id (adId) from the current browser. A promise is returned
+ * because a CIS call is done to generate a new adId if no cookie is
+ * found.
+ *
+ * *Note*: This method will return a Promise that is always rejected on node
+ * environments.
+ * @category Identifiers
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ */
+declare const getAdId: (builders: Builders, sdkState: SDKState) => Promise<string | undefined>;
+/**
+ * Get the Advertisement Identifiers for a Vendor or all Vendors.
+ * @param builders
+ * @param sdkState
+ * @category Identifiers
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ */
+declare const getAdvertisingIdentifiers: (builders: Builders, sdkState: SDKState) => Promise<AdvertisingIdentifiers>;
+export { getAdId, getIncludeAdvertising, getAdvertisingIdentifiers };

package/dist/types/identity/cis.d.ts

@@ -0,0 +1,21 @@
+import type { PPIDsByVendor } from '@schibsted/pulse-cis-sync';
+import { clearCookieJweIfStale } from '@schibsted/pulse-cis-sync';
+import type { Builders, SDKState } from '../Tracker';
+declare const requireCisSyncCallForAdvertisingIds: () => void;
+/**
+ * Sync our ids with cis given the userId from the event or builders.
+ * @param data the event parameters (the data passed to `.track()`),
+ * if called in a context where an event is being sent.
+ *
+ * @param builders
+ * @param config
+ * @returns the parsed pulse cookie after syncing with cis.
+ * @category Identifiers
+ */
+declare const cisSync: (data?: unknown, builders?: Builders, config?: SDKState) => Promise<{
+    adId?: string;
+    doTracking: boolean;
+    environmentId?: string;
+    ppId?: PPIDsByVendor;
+}>;
+export { clearCookieJweIfStale, cisSync, requireCisSyncCallForAdvertisingIds };

package/dist/types/identity/device.d.ts

@@ -0,0 +1,12 @@
+import type { Builders, SDKState } from '../Tracker';
+/**
+ * Get the environment id from the current browser. A promise is returned
+ * because a CIS call is done to generate a new environmentId if no cookie is
+ * found.
+ *
+ * *Note*: This method will return a Promise that is always rejected on node
+ * environments.
+ * @category Identifiers
+ */
+declare const getEnvironmentId: (builders: Builders, sdkState: SDKState) => Promise<string | undefined>;
+export { getEnvironmentId };

package/dist/types/identity/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actor';
+export * from './advertising';
+export * from './cis';
+export * from './device';

package/dist/types/index.d.ts

@@ -0,0 +1,31 @@
+import T from './Tracker';
+export default T;
+export * as EventBuilders from './builders';
+export { TrackerEventInput } from './builders/events-node';
+export * from './Tracker';
+export { EventInput } from './types';
+export { T as Tracker };
+export type { InputParams } from '@schibsted/tpaas-event-builder';
+export * from '@schibsted/tpaas-schemas';
+export type { IPulseTrackerCreateParams } from './createPulseTracker';
+export { createPulseTracker } from './createPulseTracker';
+export { getPulseTracker } from './getPulseTracker';
+export { AdditionalHeightInfo, LeaveEngagement, LeaveEvent, LeaveEventBuilder, LeaveEventOptions, } from './leaveTracking/types';
+export { subscribe, subscribeOnce, subscribeWithState, unsubscribe } from './Tracker';
+/**
+ * TPaaS specific type exports
+ */
+export type { AudioPageLeaveTrackingOptions, LeaveAudioInput, LeaveStoriesInput, LeaveTrackingDisabled, LeaveTrackingOptions, TrackViewAudioPageOptions, TrackViewEventOptions, TrackViewVideoPageOptions, VideoPageLeaveTrackingOptions, } from './types';
+/**
+ * Media Wrapper Types exports below
+ */
+export type { ClickUIElementEvent, ClickUIElementInputObject, ClickUIElementInputProperties, ClickUIElementOutputObject, } from './wrapper/engagement/ui-element/types.js';
+export type { Actor, BaseEvent, BaseEventCustom, BaseEventObject, BaseEventOrigin, BaseEventProvider, EventProperties, } from './wrapper/types/base-event.js';
+export type { AccessLevel, Layout, NavigationType, Page, PageType, Placement, Target, TargetCategory, TargetType, } from './wrapper/types/event.js';
+export type { ViewArticleEvent, ViewArticleInputObject, ViewArticleInputProperties, ViewArticleOutputObject, } from './wrapper/view/article/types.js';
+export type { ViewFrontpageEvent, ViewFrontpageInputObject, ViewFrontpageInputProperties, ViewFrontpageOutputObject, } from './wrapper/view/frontpage/types.js';
+export type { ViewListingEvent, ViewListingInputObject, ViewListingInputProperties, ViewListingOutputObject, } from './wrapper/view/listing/types.js';
+export type { ViewLoginPosterEvent, ViewLoginPosterInputObject, ViewLoginPosterInputProperties, ViewLoginPosterOutputObject, } from './wrapper/view/loginposter/types.js';
+export type { ViewPageEvent, ViewPageInputObject, ViewPageInputProperties, ViewPageOutputObject, } from './wrapper/view/page/types.js';
+export type { ViewSalesPosterEvent, ViewSalesPosterInputObject, ViewSalesPosterInputProperties, ViewSalesPosterOutputObject, } from './wrapper/view/salesposter/types.js';
+export type { ViewUIElementEvent, ViewUIElementInputObject, ViewUIElementInputProperties, ViewUIElementOutputObject, } from './wrapper/view/ui-element/types.js';

package/dist/types/leaveTracking/constants.d.ts

@@ -0,0 +1,26 @@
+import type { LeaveEvent } from './types';
+export declare const DEFAULT_ACTIVITY_DURATION: () => {
+    value: number;
+    interval: undefined;
+    timeSinceLastActivity: number;
+};
+export declare const DEFAULT_VIEWED_CONTENT: () => {
+    objectViewPercentage: number;
+    maxObjectViewPercentage: number;
+    pageViewPercentage: number;
+    maxPageViewPercentage: number;
+    pageScrollPosition: number;
+    maxPageScrollPosition: number;
+};
+export declare const DEFAULT_PAGE_LEAVE_EVENT: () => {
+    type: string;
+    engagement: {
+        objectViewPercentage: number;
+        maxObjectViewPercentage: number;
+        pageViewPercentage: number;
+        maxPageViewPercentage: number;
+        pageScrollPosition: number;
+        maxPageScrollPosition: number;
+    };
+};
+export declare const DEFAULT_LEAVE_EVENT_BUILDER: () => () => LeaveEvent;

package/dist/types/leaveTracking/index.d.ts

@@ -0,0 +1,23 @@
+import type Tracker from '../Tracker';
+import type { LeaveEvent, LeaveEventBuilder, LeaveEventOptions, Listener } from './types';
+export declare function addPageLeaveTracking(tracker: Tracker, objectElement: Element, pageElement: Element, eventBuilder?: LeaveEventBuilder, options?: LeaveEventOptions): void;
+export declare function leaveTrackingIsActive(): boolean;
+export declare function removePageLeaveTracking(tracker: Tracker): void;
+/**
+ * Update page leave tracking
+ * @param objectElement new object element to track
+ * @param pageElement new page element to track
+ * @param resetProperties if ALL engagement properties should be reset (duration, scroll etc.)
+ */
+export declare function updatePageLeaveTracking(objectElement: Element, pageElement: Element, resetProperties: boolean): void;
+export declare const resetViewedContent: () => void;
+export declare function updatePageLeaveEvent(leaveEvent: LeaveEvent): void;
+export declare function trackActivePageLeave(tracker: Tracker, providedEvent?: LeaveEvent, eventName?: string): void;
+export declare function trackPageLeave(tracker: Tracker, providedEvent?: LeaveEvent, eventName?: string): Promise<void>;
+export declare function updateViewedContent(objectElement: Element, pageElement: Element): void;
+export declare const calculateScrolledPixels: (element: Element) => number;
+export declare const calculateScrollPosition: (element: Element) => number;
+export declare function addEventListeners(events: string[], handler: () => void, options?: boolean | AddEventListenerOptions): Listener[];
+export declare function removeEventListeners(eventListeners: Listener[], options?: {
+    capture?: boolean;
+}): Listener[];

package/dist/types/leaveTracking/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Function that builds a LeaveEvent
+ * @internal
+ */
+export type LeaveEventBuilder = () => LeaveEvent;
+/**
+ * Options for Leave event tracking
+ */
+export interface LeaveEventOptions {
+    objectResizable?: boolean;
+    additionalHeightBuilder?: () => AdditionalHeightInfo;
+}
+/**
+ * Leave event type
+ */
+export type LeaveEvent = {
+    type?: string;
+    engagement?: LeaveEngagement;
+    object?: {
+        'spt:custom'?: {
+            'spt:eventName'?: string;
+        };
+    };
+    [k: string]: unknown | undefined;
+};
+/**
+ * Engagement data included in leave events
+ */
+export type LeaveEngagement = {
+    activityDuration: number;
+    duration: number;
+    maxObjectViewPercentage: number;
+    maxPageScrollPosition: number;
+    maxPageViewPercentage: number;
+    objectViewPercentage: number;
+    pageScrollPosition: number;
+    pageViewPercentage: number;
+};
+/**
+ * Currently supported browser events
+ */
+export declare enum BrowserEvents {
+    BEFORE_UNLOAD = "beforeunload",
+    PAGE_HIDE = "pagehide",
+    POP_STATE = "popstate",
+    VISIBILITY_CHANGE = "visibilitychange",
+    SCROLL = "scroll",
+    RESIZE = "resize",
+    MOUSEDOWN = "mousedown",
+    MOUSEMOVE = "mousemove",
+    KEYDOWN = "keydown",
+    TOUCHSTART = "touchstart"
+}
+export type Listener = [name: string, listener: () => void];
+/**
+ * Data about user activity duration
+ */
+export type ActivityDuration = {
+    value: number;
+    interval: number | undefined;
+    timeSinceLastActivity: number;
+};
+/**
+ * Used to provide extra height to view %-calculations for objects that have fake-scrolls or similar
+ * For instance if you have an element that captures scroll for about 1000px
+ * you would report totalHeight 1000px and then viewedHeight 0px if the user had not yet started scrolling, 500px if
+ * scrolled halfway through or 1000px if the user had scrolled to the end or past that element
+ */
+export interface AdditionalHeightInfo {
+    /**
+     * The number of px to add to the object & page height
+     */
+    totalHeight: number;
+    /**
+     * The number of px to add to the user's current scroll depth
+     */
+    viewedHeight: number;
+}

package/dist/types/leaveTrackingTpaas/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_ACTIVITY_DURATION: () => {
+    value: number;
+    interval: undefined;
+    timeSinceLastActivity: number;
+};
+export declare const DEFAULT_PAGE_LEAVE_EVENT: () => {
+    objectViewPercentage: number;
+    maxObjectViewPercentage: number;
+    pageViewPercentage: number;
+    maxPageViewPercentage: number;
+    pageScrollPosition: number;
+    maxPageScrollPosition: number;
+};