@leanbase.com/js 0.1.3 → 0.2.0-alpha.0

package/dist/utils/blocked-uas.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_BLOCKED_UA_STRS: string[];
+/**
+ * Block various web spiders from executing our JS and sending false capturing data
+ */
+export declare const isBlockedUA: (ua: string, customBlockedUserAgents: string[]) => boolean;
+export interface NavigatorUAData {
+    brands?: {
+        brand: string;
+        version: string;
+    }[];
+}
+declare global {
+    interface Navigator {
+        userAgentData?: NavigatorUAData;
+    }
+}
+export declare const isLikelyBot: (navigator: Navigator | undefined, customBlockedUserAgents: string[]) => boolean;

package/dist/utils/element-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function isElementInToolbar(el: EventTarget | null): boolean;
+export declare function isElementNode(el: Node | Element | undefined | null): el is Element;
+export declare function isTag(el: Element | undefined | null, tag: string): el is HTMLElement;
+export declare function isTextNode(el: Element | undefined | null): el is HTMLElement;
+export declare function isDocumentFragment(el: Element | ParentNode | undefined | null): el is DocumentFragment;

package/dist/utils/event-utils.d.ts

@@ -0,0 +1,22 @@
+import { Properties } from '../types';
+export declare const PERSONAL_DATA_CAMPAIGN_PARAMS: string[];
+export declare const CAMPAIGN_PARAMS: string[];
+export declare const EVENT_TO_PERSON_PROPERTIES: string[];
+export declare const MASKED = "<masked>";
+export declare const COOKIE_CAMPAIGN_PARAMS: string[];
+export declare function getCampaignParams(customTrackedParams?: string[], maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[] | undefined): Record<string, string>;
+export declare function getSearchInfo(): Record<string, any>;
+export declare function getBrowserLanguage(): string | undefined;
+export declare function getBrowserLanguagePrefix(): string | undefined;
+export declare function getReferrer(): string;
+export declare function getReferringDomain(): string;
+export declare function getReferrerInfo(): Record<string, any>;
+export declare function getPersonInfo(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[]): {
+    r: string;
+    u: string | undefined;
+};
+export declare function getPersonPropsFromInfo(info: Record<string, any>): Record<string, any>;
+export declare function getInitialPersonPropsFromInfo(info: Record<string, any>): Record<string, any>;
+export declare function getTimezone(): string | undefined;
+export declare function getTimezoneOffset(): number | undefined;
+export declare function getEventProperties(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[]): Properties;

package/dist/utils/index.d.ts

@@ -0,0 +1,44 @@
+import { Properties } from '../types';
+export type Breaker = {};
+export declare const ArrayProto: any[];
+export declare const nativeForEach: (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
+export declare const nativeIndexOf: (searchElement: any, fromIndex?: number) => number;
+declare const win: (Window & typeof globalThis) | undefined;
+export declare const navigator: Navigator | undefined;
+export declare const document: Document | undefined;
+export declare const location: Location | undefined;
+export declare const fetch: typeof globalThis.fetch | undefined;
+export declare const XMLHttpRequest: {
+    new (): XMLHttpRequest;
+    prototype: XMLHttpRequest;
+    readonly UNSENT: 0;
+    readonly OPENED: 1;
+    readonly HEADERS_RECEIVED: 2;
+    readonly LOADING: 3;
+    readonly DONE: 4;
+} | undefined;
+export declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+} | undefined;
+export declare const userAgent: string | undefined;
+export { win as window };
+export declare function eachArray<E = any>(obj: E[] | null | undefined, iterator: (value: E, key: number) => void | Breaker, thisArg?: any): void;
+/**
+ * @param {*=} obj
+ * @param {function(...*)=} iterator
+ * @param {Object=} thisArg
+ */
+export declare function each(obj: any, iterator: (value: any, key: any) => void | Breaker, thisArg?: any): void;
+export declare const extend: (obj: Record<string, any>, ...args: Record<string, any>[]) => Record<string, any>;
+export declare const extendArray: <T>(obj: T[], ...args: T[][]) => T[];
+export declare const include: (obj: null | string | Array<any> | Record<string, any>, target: any) => boolean | Breaker;
+/**
+ * Object.entries() polyfill
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+ */
+export declare function entries<T = any>(obj: Record<string, T>): [string, T][];
+export declare function addEventListener(element: Window | Document | Element | undefined, event: string, callback: EventListener, options?: AddEventListenerOptions): void;
+export declare const stripEmptyProperties: (p: Properties) => Properties;
+export declare function isCrossDomainCookie(documentLocation: Location | undefined): boolean;
+export declare function copyAndTruncateStrings<T extends Record<string, any> = Record<string, any>>(object: T, maxStringLength: number | null): T;

package/dist/utils/request-utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * IE11 doesn't support `new URL`
+ * so we can create an anchor element and use that to parse the URL
+ * there's a lot of overlap between HTMLHyperlinkElementUtils and URL
+ * meaning useful properties like `pathname` are available on both
+ */
+export declare const convertToURL: (url: string) => HTMLAnchorElement | null;
+export declare const formDataToQuery: (formdata: Record<string, any> | FormData, arg_separator?: string) => string;
+export declare const getQueryParam: (url: string, param: string) => string;
+export declare const maskQueryParams: <T extends string | undefined>(url: T, maskedParams: string[] | undefined, mask: string) => T extends string ? string : undefined;
+export declare const _getHashParam: (hash: string, param: string) => string | null;
+export declare const isLocalhost: () => boolean;

package/dist/utils/simple-event-emitter.d.ts

@@ -0,0 +1,6 @@
+export declare class SimpleEventEmitter {
+    private _events;
+    constructor();
+    on(event: string, listener: (...args: any[]) => void): () => void;
+    emit(event: string, payload: any): void;
+}

package/dist/utils/user-agent-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This function detects which browser is running this script.
+ * The order of the checks are important since many user agents
+ * include keywords used in later checks.
+ */
+export declare const detectBrowser: (user_agent: string, vendor: string | undefined) => string;
+/**
+ * This function detects which browser version is running this script,
+ * parsing major and minor version (e.g., 42.1). User agent strings from:
+ * http://www.useragentstring.com/pages/useragentstring.php
+ *
+ * `navigator.vendor` is passed in and used to help with detecting certain browsers
+ * NB `navigator.vendor` is deprecated and not present in every browser
+ */
+export declare const detectBrowserVersion: (userAgent: string, vendor: string | undefined) => number | null;
+export declare const detectOS: (user_agent: string) => [string, string];
+export declare const detectDevice: (user_agent: string) => string;
+export declare const detectDeviceType: (user_agent: string) => string;

package/dist/uuidv7.d.ts

@@ -0,0 +1,43 @@
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ *
+ * from https://github.com/LiosK/uuidv7/blob/e501462ea3d23241de13192ceae726956f9b3b7d/src/index.ts
+ */
+/** Represents a UUID as a 16-byte byte array. */
+export declare class UUID {
+    readonly bytes: Readonly<Uint8Array>;
+    /** @param bytes - The 16-byte byte array representation. */
+    constructor(bytes: Readonly<Uint8Array>);
+    /**
+     * Builds a byte array from UUIDv7 field values.
+     *
+     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+     * @param randA - A 12-bit `rand_a` field value.
+     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+     */
+    static fromFieldsV7(unixTsMs: number, randA: number, randBHi: number, randBLo: number): UUID;
+    /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+    toString(): string;
+    /** Creates an object from `this`. */
+    clone(): UUID;
+    /** Returns true if `this` is equivalent to `other`. */
+    equals(other: UUID): boolean;
+    /**
+     * Returns a negative integer, zero, or positive integer if `this` is less
+     * than, equal to, or greater than `other`, respectively.
+     */
+    compareTo(other: UUID): number;
+}
+/**
+ * Generates a UUIDv7 string.
+ *
+ * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+ * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ */
+export declare const uuidv7: () => string;
+export declare const uuid7ToTimestampMs: (uuid: string) => number;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.2.0-alpha.0";

package/lib/autocapture-utils.d.ts

@@ -0,0 +1,17 @@
+import { AutocaptureConfig, LeanbaseConfig, Properties } from './types';
+export declare function splitClassString(s: string): string[];
+export declare function getClassNames(el: Element): string[];
+export declare function makeSafeText(s: string | null | undefined): string | null;
+export declare function getSafeText(el: Element): string;
+export declare function getEventTarget(e: Event): Element | null;
+export declare const autocaptureCompatibleElements: string[];
+export declare function getParentElement(curEl: Element): Element | false;
+export declare function shouldCaptureRageclick(el: Element | null, _config: LeanbaseConfig['rageclick']): boolean;
+export declare function shouldCaptureDomEvent(el: Element, event: Event, autocaptureConfig?: AutocaptureConfig | undefined, captureOnAnyElement?: boolean, allowedEventTypes?: string[]): boolean;
+export declare function shouldCaptureElement(el: Element): boolean;
+export declare function isSensitiveElement(el: Element): boolean;
+export declare function shouldCaptureValue(value: string, anchorRegexes?: boolean): boolean;
+export declare function isAngularStyleAttr(attributeName: string): boolean;
+export declare function getDirectAndNestedSpanText(target: Element): string;
+export declare function getNestedSpanText(target: Element): string;
+export declare function getElementsChainString(elements: Properties[]): string;