@workleap/logrocket 1.0.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["webpack://@workleap/logrocket/./src/index.ts"],"sourcesContent":["export type { LogRocketSdkOptionsTransformer } from \"./applyTransformers.ts\";\nexport { createDefaultUserTraits, type LogRocketIdentification, type LogRocketUserTraits } from \"./createDefaultUserTraits.ts\";\nexport type * from \"./logRocketTypes.ts\";\nexport { registerLogRocketInstrumentation } from \"./registerLogRocketInstrumentation.ts\";\n\n"],"names":["createDefaultUserTraits","registerLogRocketInstrumentation"],"mappings":";;;;;;;;AAC+H;AAEtC"}

package/dist/logRocketTypes.d.ts

@@ -0,0 +1,24 @@
+import type LogRocket from "logrocket";
+export type LogRocketSdkOptions = NonNullable<Parameters<(typeof LogRocket)["init"]>[1]>;
+export interface LogRocketRequest {
+    reqId: string;
+    url: string;
+    headers: {
+        [key: string]: string | null | undefined;
+    };
+    body?: string;
+    method: string;
+    referrer?: string;
+    mode?: string;
+    credentials?: string;
+}
+export interface LogRocketResponse {
+    reqId: string;
+    status?: number;
+    headers: {
+        [key: string]: string | null | undefined;
+    };
+    body?: string;
+    method: string;
+    url?: string;
+}

package/dist/logRocketTypes.js

@@ -0,0 +1,7 @@
+
+;// CONCATENATED MODULE: ./src/logRocketTypes.ts
+// Typings are not exposed by the library, copied from the LogRocket package.
+
+
+
+//# sourceMappingURL=logRocketTypes.js.map

package/dist/logRocketTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logRocketTypes.js","sources":["webpack://@workleap/logrocket/./src/logRocketTypes.ts"],"sourcesContent":["import type LogRocket from \"logrocket\";\n\n// Typings are not exposed by the library.\nexport type LogRocketSdkOptions = NonNullable<Parameters<(typeof LogRocket)[\"init\"]>[1]>;\n\n// Typings are not exposed by the library, copied from the LogRocket package.\nexport interface LogRocketRequest {\n    reqId: string;\n    url: string;\n    headers: {\n        [key: string]: string | null | undefined;\n    };\n    body?: string;\n    method: string;\n    referrer?: string;\n    mode?: string;\n    credentials?: string;\n}\n\n// Typings are not exposed by the library, copied from the LogRocket package.\nexport interface LogRocketResponse {\n    reqId: string;\n    status?: number;\n    headers: {\n        [key: string]: string | null | undefined;\n    };\n    body?: string;\n    method: string;\n    url?: string;\n}\n"],"names":[],"mappings":";;AAmBA,6EAA6E;AAU5E"}

package/dist/registerLogRocketInstrumentation.d.ts

@@ -0,0 +1,20 @@
+import { type LogRocketSdkOptionsTransformer } from "./applyTransformers.ts";
+import type { LogRocketSdkOptions } from "./logRocketTypes.ts";
+export declare const IsRegisteredFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__";
+export declare const RegisterGetSessionUrlFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__";
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export interface RegisterLogRocketInstrumentationOptions {
+    rootHostname?: LogRocketSdkOptions["rootHostname"];
+    privateFieldNames?: string[];
+    privateQueryParameterNames?: string[];
+    verbose?: boolean;
+    transformers?: LogRocketSdkOptionsTransformer[];
+}
+export declare function getLogRocketSdkOptions(options: RegisterLogRocketInstrumentationOptions): LogRocketSdkOptions;
+export declare function __resetRegistrationGuard(): void;
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export declare function registerLogRocketInstrumentation(appId: string, options?: RegisterLogRocketInstrumentationOptions): void;

package/dist/registerLogRocketInstrumentation.js

@@ -0,0 +1,146 @@
+import { getBootstrappingStore, getTelemetryContext } from "@workleap/telemetry";
+import logrocket from "logrocket";
+import logrocket_fuzzy_search_sanitizer from "logrocket-fuzzy-search-sanitizer";
+import { applyTransformers } from "./applyTransformers.js";
+import { DeviceIdTrait, TelemetryIdTrait } from "./createDefaultUserTraits.js";
+import { createRequestSanitizer } from "./createRequestSanitizer.js";
+import { createResponseSanitizer } from "./createResponseSanitizer.js";
+import { createUrlSanitizer } from "./createUrlSanitizer.js";
+import { HasExecutedGuard } from "./HasExecutedGuard.js";
+
+;// CONCATENATED MODULE: external "@workleap/telemetry"
+
+;// CONCATENATED MODULE: external "logrocket"
+
+;// CONCATENATED MODULE: external "logrocket-fuzzy-search-sanitizer"
+
+;// CONCATENATED MODULE: external "./applyTransformers.js"
+
+;// CONCATENATED MODULE: external "./createDefaultUserTraits.js"
+
+;// CONCATENATED MODULE: external "./createRequestSanitizer.js"
+
+;// CONCATENATED MODULE: external "./createResponseSanitizer.js"
+
+;// CONCATENATED MODULE: external "./createUrlSanitizer.js"
+
+;// CONCATENATED MODULE: external "./HasExecutedGuard.js"
+
+;// CONCATENATED MODULE: ./src/registerLogRocketInstrumentation.ts
+
+
+
+
+
+
+
+
+
+const IsRegisteredFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__";
+const RegisterGetSessionUrlFunctionName = "__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__";
+const DefaultPrivateFieldNames = [
+    "email",
+    "personalEmail",
+    "phoneNumber",
+    "password",
+    "firstName",
+    "lastName",
+    "givenName",
+    "fullName",
+    "gender",
+    "timeZone",
+    "birthday"
+];
+const DefaultPrivateQueryParameterNames = [
+    "token",
+    "email",
+    "password"
+];
+// The function return type is mandatory, otherwise we got an error TS4058.
+function getLogRocketSdkOptions(options) {
+    const { rootHostname = "workleap.com", privateFieldNames = [], privateQueryParameterNames = [], verbose = false, transformers = [] } = options;
+    const mergedPrivateFieldNames = DefaultPrivateFieldNames.concat(privateFieldNames);
+    const mergedPrivateQueryParameterNames = DefaultPrivateQueryParameterNames.concat(privateQueryParameterNames);
+    // The "LogrocketFuzzySearch.setup" code is awkward. For now, we prefer to play it safe and call it once here, then forward the sanitize functions
+    // to the appropriate factories.
+    // No clue why the "setup" method is not available. This package is shady.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const { requestSanitizer: fuzzyRequestSanitizer, responseSanitizer: fuzzyResponseSanitizer } = logrocket_fuzzy_search_sanitizer.setup(mergedPrivateFieldNames);
+    const sdkOptions = {
+        console: {
+            isEnabled: false
+        },
+        rootHostname,
+        dom: {
+            textSanitizer: true,
+            inputSanitizer: true
+        },
+        network: {
+            requestSanitizer: createRequestSanitizer(fuzzyRequestSanitizer),
+            responseSanitizer: createResponseSanitizer(fuzzyResponseSanitizer)
+        },
+        browser: {
+            urlSanitizer: createUrlSanitizer(mergedPrivateQueryParameterNames)
+        },
+        shouldDebugLog: verbose
+    };
+    return applyTransformers(sdkOptions, transformers, {
+        verbose
+    });
+}
+const registrationGuard = new HasExecutedGuard();
+// This function should only be used by tests.
+function __resetRegistrationGuard() {
+    registrationGuard.reset();
+}
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */ function registerLogRocketInstrumentation(appId, options = {}) {
+    const { verbose = false } = options;
+    registrationGuard.throw("[logrocket] The LogRocket instrumentation has already been registered. Did you call the \"registerLogRocketInstrumentation\" function twice?");
+    const sdkOptions = getLogRocketSdkOptions(options);
+    // Session starts anonymously when LogRocket.init() is called.
+    logrocket.init(appId, sdkOptions);
+    const telemetryContext = getTelemetryContext({
+        verbose
+    });
+    // LogRocket maintains the same session even if the user starts as anonymous and later becomes identified via LogRocket.identify().
+    // If LogRocket.identify is called multiple times during a recording, you can search for any of the identified users in the session.
+    logrocket.identify(telemetryContext.deviceId, {
+        [DeviceIdTrait]: telemetryContext.deviceId,
+        [TelemetryIdTrait]: telemetryContext.telemetryId
+    });
+    if (verbose) {
+        logrocket.getSessionURL((url)=>{
+            console.log("[logrocket] Session replay URL is now available:", url);
+        });
+    }
+    // Indicates to the host applications that logrocket has been initialized.
+    // It's useful in cases where an "add-on", like the platform widgets needs
+    // to know whether or not the host application is using LogRocket.
+    // While there are ways that the host application could tell to an "add-on" if
+    // it's using LogRocket or not, doing it this way is transparent for the consumer,
+    // which is great for DX.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    globalThis[IsRegisteredFunctionName] = true;
+    // While consumers could directly call LogRocket.getSessionURL, by doing it this way,
+    // it allow consumers to not take a direct dependency on the "logrocket" package.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    globalThis[RegisterGetSessionUrlFunctionName] = (listener)=>{
+        logrocket.getSessionURL(listener);
+    };
+    // Let the other telemetry libraries know that LogRocket instrumentation is ready.
+    getBootstrappingStore().dispatch({
+        type: "logrocket-ready"
+    });
+    if (verbose) {
+        console.log("[logrocket] LogRocket instrumentation is registered.");
+    }
+}
+
+export { IsRegisteredFunctionName, RegisterGetSessionUrlFunctionName, __resetRegistrationGuard, getLogRocketSdkOptions, registerLogRocketInstrumentation };
+
+//# sourceMappingURL=registerLogRocketInstrumentation.js.map

package/dist/registerLogRocketInstrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerLogRocketInstrumentation.js","sources":["webpack://@workleap/logrocket/./src/registerLogRocketInstrumentation.ts"],"sourcesContent":["import { getBootstrappingStore, getTelemetryContext } from \"@workleap/telemetry\";\nimport LogRocket from \"logrocket\";\nimport LogrocketFuzzySanitizer from \"logrocket-fuzzy-search-sanitizer\";\nimport { applyTransformers, type LogRocketSdkOptionsTransformer } from \"./applyTransformers.ts\";\nimport { DeviceIdTrait, TelemetryIdTrait } from \"./createDefaultUserTraits.ts\";\nimport { createRequestSanitizer } from \"./createRequestSanitizer.ts\";\nimport { createResponseSanitizer } from \"./createResponseSanitizer.ts\";\nimport { createUrlSanitizer } from \"./createUrlSanitizer.ts\";\nimport { HasExecutedGuard } from \"./HasExecutedGuard.ts\";\nimport type { LogRocketSdkOptions } from \"./logRocketTypes.ts\";\n\nexport const IsRegisteredFunctionName = \"__WLP_LOGROCKET_INSTRUMENTATION_IS_REGISTERED__\";\nexport const RegisterGetSessionUrlFunctionName = \"__WLP_LOGROCKET_INSTRUMENTATION_REGISTER_GET_SESSION_URL_LISTENER__\";\n\nconst DefaultPrivateFieldNames = [\n    \"email\",\n    \"personalEmail\",\n    \"phoneNumber\",\n    \"password\",\n    \"firstName\",\n    \"lastName\",\n    \"givenName\",\n    \"fullName\",\n    \"gender\",\n    \"timeZone\",\n    \"birthday\"\n];\n\nconst DefaultPrivateQueryParameterNames = [\n    \"token\",\n    \"email\",\n    \"password\"\n];\n\n/**\n * @see https://workleap.github.io/wl-telemetry\n */\nexport interface RegisterLogRocketInstrumentationOptions {\n    // Set to capture traffic from all subdomains under one session: https://docs.logrocket.com/reference/roothostname.\n    rootHostname?: LogRocketSdkOptions[\"rootHostname\"];\n    privateFieldNames?: string[];\n    privateQueryParameterNames?: string[];\n    verbose?: boolean;\n    transformers?: LogRocketSdkOptionsTransformer[];\n}\n\n// The function return type is mandatory, otherwise we got an error TS4058.\nexport function getLogRocketSdkOptions(options: RegisterLogRocketInstrumentationOptions): LogRocketSdkOptions {\n    const {\n        rootHostname = \"workleap.com\",\n        privateFieldNames = [],\n        privateQueryParameterNames = [],\n        verbose = false,\n        transformers = []\n    } = options;\n\n    const mergedPrivateFieldNames = DefaultPrivateFieldNames.concat(privateFieldNames);\n    const mergedPrivateQueryParameterNames = DefaultPrivateQueryParameterNames.concat(privateQueryParameterNames);\n\n    // The \"LogrocketFuzzySearch.setup\" code is awkward. For now, we prefer to play it safe and call it once here, then forward the sanitize functions\n    // to the appropriate factories.\n    // No clue why the \"setup\" method is not available. This package is shady.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    const { requestSanitizer: fuzzyRequestSanitizer, responseSanitizer: fuzzyResponseSanitizer } = LogrocketFuzzySanitizer.setup(mergedPrivateFieldNames);\n\n    const sdkOptions = {\n        console: {\n            isEnabled: false\n        },\n        rootHostname,\n        dom: {\n            textSanitizer: true,\n            inputSanitizer: true\n        },\n        network: {\n            requestSanitizer: createRequestSanitizer(fuzzyRequestSanitizer),\n            responseSanitizer: createResponseSanitizer(fuzzyResponseSanitizer)\n        },\n        browser: {\n            urlSanitizer: createUrlSanitizer(mergedPrivateQueryParameterNames)\n        },\n        shouldDebugLog: verbose\n    } satisfies LogRocketSdkOptions;\n\n    return applyTransformers(sdkOptions, transformers, {\n        verbose\n    });\n}\n\nconst registrationGuard = new HasExecutedGuard();\n\n// This function should only be used by tests.\nexport function __resetRegistrationGuard() {\n    registrationGuard.reset();\n}\n\n/**\n * @see https://workleap.github.io/wl-telemetry\n */\nexport function registerLogRocketInstrumentation(appId: string, options: RegisterLogRocketInstrumentationOptions = {}) {\n    const {\n        verbose = false\n    } = options;\n\n    registrationGuard.throw(\"[logrocket] The LogRocket instrumentation has already been registered. Did you call the \\\"registerLogRocketInstrumentation\\\" function twice?\");\n\n    const sdkOptions = getLogRocketSdkOptions(options);\n\n    // Session starts anonymously when LogRocket.init() is called.\n    LogRocket.init(appId, sdkOptions);\n\n    const telemetryContext = getTelemetryContext({ verbose });\n\n    // LogRocket maintains the same session even if the user starts as anonymous and later becomes identified via LogRocket.identify().\n    // If LogRocket.identify is called multiple times during a recording, you can search for any of the identified users in the session.\n    LogRocket.identify(telemetryContext.deviceId, {\n        [DeviceIdTrait]: telemetryContext.deviceId,\n        [TelemetryIdTrait]: telemetryContext.telemetryId\n    });\n\n    if (verbose) {\n        LogRocket.getSessionURL(url => {\n            console.log(\"[logrocket] Session replay URL is now available:\", url);\n        });\n    }\n\n    // Indicates to the host applications that logrocket has been initialized.\n    // It's useful in cases where an \"add-on\", like the platform widgets needs\n    // to know whether or not the host application is using LogRocket.\n    // While there are ways that the host application could tell to an \"add-on\" if\n    // it's using LogRocket or not, doing it this way is transparent for the consumer,\n    // which is great for DX.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[IsRegisteredFunctionName] = true;\n\n    // While consumers could directly call LogRocket.getSessionURL, by doing it this way,\n    // it allow consumers to not take a direct dependency on the \"logrocket\" package.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    globalThis[RegisterGetSessionUrlFunctionName] = listener => {\n        LogRocket.getSessionURL(listener);\n    };\n\n    // Let the other telemetry libraries know that LogRocket instrumentation is ready.\n    getBootstrappingStore().dispatch({ type: \"logrocket-ready\" });\n\n    if (verbose) {\n        console.log(\"[logrocket] LogRocket instrumentation is registered.\");\n    }\n}\n"],"names":["getBootstrappingStore","getTelemetryContext","LogRocket","LogrocketFuzzySanitizer","applyTransformers","DeviceIdTrait","TelemetryIdTrait","createRequestSanitizer","createResponseSanitizer","createUrlSanitizer","HasExecutedGuard","IsRegisteredFunctionName","RegisterGetSessionUrlFunctionName","DefaultPrivateFieldNames","DefaultPrivateQueryParameterNames","getLogRocketSdkOptions","options","rootHostname","privateFieldNames","privateQueryParameterNames","verbose","transformers","mergedPrivateFieldNames","mergedPrivateQueryParameterNames","fuzzyRequestSanitizer","fuzzyResponseSanitizer","sdkOptions","registrationGuard","__resetRegistrationGuard","registerLogRocketInstrumentation","appId","telemetryContext","url","console","globalThis","listener"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAiF;AAC/C;AACqC;AACyB;AACjB;AACV;AACE;AACV;AACJ;AAGlD,MAAMW,2BAA2B,kDAAkD;AACnF,MAAMC,oCAAoC,sEAAsE;AAEvH,MAAMC,2BAA2B;IAC7B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAED,MAAMC,oCAAoC;IACtC;IACA;IACA;CACH;AAcD,2EAA2E;AACpE,SAASC,uBAAuBC,OAAgD;IACnF,MAAM,EACFC,eAAe,cAAc,EAC7BC,oBAAoB,EAAE,EACtBC,6BAA6B,EAAE,EAC/BC,UAAU,KAAK,EACfC,eAAe,EAAE,EACpB,GAAGL;IAEJ,MAAMM,0BAA0BT,yBAAyB,MAAM,CAACK;IAChE,MAAMK,mCAAmCT,kCAAkC,MAAM,CAACK;IAElF,kJAAkJ;IAClJ,gCAAgC;IAChC,0EAA0E;IAC1E,6DAA6D;IAC7D,aAAa;IACb,MAAM,EAAE,kBAAkBK,qBAAqB,EAAE,mBAAmBC,sBAAsB,EAAE,GAAGtB,sCAA6B,CAACmB;IAE7H,MAAMI,aAAa;QACf,SAAS;YACL,WAAW;QACf;QACAT;QACA,KAAK;YACD,eAAe;YACf,gBAAgB;QACpB;QACA,SAAS;YACL,kBAAkBV,sBAAsBA,CAACiB;YACzC,mBAAmBhB,uBAAuBA,CAACiB;QAC/C;QACA,SAAS;YACL,cAAchB,kBAAkBA,CAACc;QACrC;QACA,gBAAgBH;IACpB;IAEA,OAAOhB,iBAAiBA,CAACsB,YAAYL,cAAc;QAC/CD;IACJ;AACJ;AAEA,MAAMO,oBAAoB,IAAIjB,gBAAgBA;AAE9C,8CAA8C;AACvC,SAASkB;IACZD,kBAAkB,KAAK;AAC3B;AAEA;;CAEC,GACM,SAASE,iCAAiCC,KAAa,EAAEd,UAAmD,CAAC,CAAC;IACjH,MAAM,EACFI,UAAU,KAAK,EAClB,GAAGJ;IAEJW,kBAAkB,KAAK,CAAC;IAExB,MAAMD,aAAaX,uBAAuBC;IAE1C,8DAA8D;IAC9Dd,cAAc,CAAC4B,OAAOJ;IAEtB,MAAMK,mBAAmB9B,mBAAmBA,CAAC;QAAEmB;IAAQ;IAEvD,mIAAmI;IACnI,oIAAoI;IACpIlB,kBAAkB,CAAC6B,iBAAiB,QAAQ,EAAE;QAC1C,CAAC1B,aAAaA,CAAC,EAAE0B,iBAAiB,QAAQ;QAC1C,CAACzB,gBAAgBA,CAAC,EAAEyB,iBAAiB,WAAW;IACpD;IAEA,IAAIX,SAAS;QACTlB,uBAAuB,CAAC8B,CAAAA;YACpBC,QAAQ,GAAG,CAAC,oDAAoDD;QACpE;IACJ;IAEA,0EAA0E;IAC1E,0EAA0E;IAC1E,kEAAkE;IAClE,8EAA8E;IAC9E,kFAAkF;IAClF,yBAAyB;IACzB,6DAA6D;IAC7D,aAAa;IACbE,UAAU,CAACvB,yBAAyB,GAAG;IAEvC,qFAAqF;IACrF,iFAAiF;IACjF,6DAA6D;IAC7D,aAAa;IACbuB,UAAU,CAACtB,kCAAkC,GAAGuB,CAAAA;QAC5CjC,uBAAuB,CAACiC;IAC5B;IAEA,kFAAkF;IAClFnC,qBAAqBA,GAAG,QAAQ,CAAC;QAAE,MAAM;IAAkB;IAE3D,IAAIoB,SAAS;QACTa,QAAQ,GAAG,CAAC;IAChB;AACJ"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@workleap/logrocket",
+  "author": "Workleap",
+  "version": "1.0.0",
+  "description": "A package containing utilities for LogRocket.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/workleap/wl-telemetry.git",
+    "directory": "packages/logrocket"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "logrocket": "^10.1.0",
+    "@workleap/telemetry": "1.0.0"
+  },
+  "dependencies": {
+    "logrocket-fuzzy-search-sanitizer": "0.0.2"
+  },
+  "devDependencies": {
+    "@rsbuild/core": "1.4.6",
+    "@rslib/core": "0.10.5",
+    "@workleap/eslint-plugin": "3.4.2",
+    "@workleap/rslib-configs": "1.0.6",
+    "@workleap/typescript-configs": "3.0.4",
+    "eslint": "8.57.1",
+    "happy-dom": "18.0.1",
+    "typescript": "5.8.3",
+    "vitest": "3.2.4"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "rslib build --config ./rslib.build.ts",
+    "eslint": "eslint . --max-warnings=-0 --cache --cache-location node_modules/.cache/eslint",
+    "typecheck": "tsc",
+    "test": "vitest --config vitest.config.ts --no-watch"
+  }
+}

package/src/HasExecutedGuard.ts

@@ -0,0 +1,19 @@
+export class HasExecutedGuard {
+    #hasExecuted: boolean = false;
+
+    throw(message: string) {
+        if (this.#hasExecuted) {
+            throw new Error(message);
+        }
+
+        this.#hasExecuted = true;
+    }
+
+    get hasExecuted() {
+        return this.#hasExecuted;
+    }
+
+    reset() {
+        this.#hasExecuted = false;
+    }
+}

package/src/applyTransformers.ts

@@ -0,0 +1,17 @@
+import type { LogRocketSdkOptions } from "./logRocketTypes.ts";
+
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export interface LogRocketSdkOptionsTransformerContext {
+    verbose: boolean;
+}
+
+export type LogRocketSdkOptionsTransformer = (options: LogRocketSdkOptions, context: LogRocketSdkOptionsTransformerContext) => LogRocketSdkOptions;
+
+// The function return type is mandatory, otherwise we got an error TS4058.
+export function applyTransformers(options: LogRocketSdkOptions, transformers: LogRocketSdkOptionsTransformer[], context: LogRocketSdkOptionsTransformerContext): LogRocketSdkOptions {
+    return transformers.reduce((acc, transformer) => transformer(acc, context), options);
+}
+
+

package/src/assertions.ts

@@ -0,0 +1,3 @@
+export function isDefined(value: unknown) {
+    return typeof value !== "undefined" && value !== undefined;
+}

package/src/createDefaultUserTraits.ts

@@ -0,0 +1,151 @@
+import { getTelemetryContext } from "@workleap/telemetry";
+import { isDefined } from "./assertions.ts";
+
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export interface LogRocketIdentification {
+    userId: string;
+    organizationId: string;
+    organizationName: string;
+    isMigratedToWorkleap: boolean;
+    isAdmin: boolean;
+    isOrganizationCreator?: boolean;
+    isExecutive?: {
+        wov?: boolean;
+        lms?: boolean;
+        onb?: boolean;
+        sks?: boolean;
+        wpm?: boolean;
+        pbd?: boolean;
+    };
+    isCollaborator?: {
+        wov?: boolean;
+        lms?: boolean;
+        onb?: boolean;
+        sks?: boolean;
+        wpm?: boolean;
+        pbd?: boolean;
+    };
+    isReportingManager?: boolean;
+    isTeamManager?: boolean;
+    planCode?: {
+        wov?: string;
+        lms?: string;
+        onb?: string;
+        sks?: string;
+        wpm?: string;
+        pbd?: string;
+    };
+}
+
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export interface LogRocketUserTraits extends Record<string, unknown> {
+    "User Id": string;
+    "Organization Id": string;
+    "Organization Name": string;
+    "Is Migrated To Workleap": boolean;
+    "Is Admin": boolean;
+    "Device Id": string;
+    "Telemetry Id": string;
+    "Is Organization Creator"?: boolean;
+    "Is Executive"?: boolean;
+    "Is Executive - Officevibe"?: boolean;
+    "Is Executive - LMS"?: boolean;
+    "Is Executive - Onboarding"?: boolean;
+    "Is Executive - Skills"?: boolean;
+    "Is Executive - Performance"?: boolean;
+    "Is Executive - Pingboard"?: boolean;
+    "Is Collaborator"?: boolean;
+    "Is Collaborator - Officevibe"?: boolean;
+    "Is Collaborator - LMS"?: boolean;
+    "Is Collaborator - Onboarding"?: boolean;
+    "Is Collaborator - Skills"?: boolean;
+    "Is Collaborator - Performance"?: boolean;
+    "Is Collaborator - Pingboard"?: boolean;
+    "Is Reporting Manager"?: boolean;
+    "Is Team Manager"?: boolean;
+    "Plan Code - Officevibe"?: string;
+    "Plan Code - LMS"?: string;
+    "Plan Code - Onboarding"?: string;
+    "Plan Code - Skills"?: string;
+    "Plan Code - Performance"?: string;
+    "Plan Code - Pingboard"?: string;
+}
+
+export const DeviceIdTrait = "Device Id";
+export const TelemetryIdTrait = "Telemetry Id";
+
+/**
+ * @see https://workleap.github.io/wl-telemetry
+ */
+export function createDefaultUserTraits(identification: LogRocketIdentification) {
+    const {
+        userId,
+        organizationId,
+        organizationName,
+        isMigratedToWorkleap,
+        isOrganizationCreator,
+        isAdmin,
+        isExecutive,
+        isCollaborator,
+        isReportingManager,
+        isTeamManager,
+        planCode
+    } = identification;
+
+    const isExecutiveInAnyProduct = Boolean(
+        isExecutive?.wov ||
+        isExecutive?.lms ||
+        isExecutive?.onb ||
+        isExecutive?.sks ||
+        isExecutive?.wpm ||
+        isExecutive?.pbd
+    );
+
+    const isCollaboratorInAnyProduct = Boolean(
+        isCollaborator?.wov ||
+        isCollaborator?.lms ||
+        isCollaborator?.onb ||
+        isCollaborator?.sks ||
+        isCollaborator?.wpm ||
+        isCollaborator?.pbd
+    );
+
+    const telemetryContext = getTelemetryContext();
+
+    return {
+        "User Id": userId,
+        "Organization Id": organizationId,
+        "Organization Name": organizationName,
+        "Is Migrated To Workleap": isMigratedToWorkleap,
+        "Is Admin": isAdmin,
+        [DeviceIdTrait]: telemetryContext ? telemetryContext.deviceId : "N/A",
+        [TelemetryIdTrait]: telemetryContext ? telemetryContext.telemetryId : "N/A",
+        ...(isDefined(isOrganizationCreator) && { "Is Organization Creator": isOrganizationCreator }),
+        ...(isExecutiveInAnyProduct && { "Is Executive": true }),
+        ...(isDefined(isExecutive?.wov) && { "Is Executive - Officevibe": isExecutive.wov }),
+        ...(isDefined(isExecutive?.lms) && { "Is Executive - LMS": isExecutive.lms }),
+        ...(isDefined(isExecutive?.onb) && { "Is Executive - Onboarding": isExecutive.onb }),
+        ...(isDefined(isExecutive?.sks) && { "Is Executive - Skills": isExecutive.sks }),
+        ...(isDefined(isExecutive?.wpm) && { "Is Executive - Performance": isExecutive.wpm }),
+        ...(isDefined(isExecutive?.pbd) && { "Is Executive - Pingboard": isExecutive.pbd }),
+        ...(isCollaboratorInAnyProduct && { "Is Collaborator": isCollaboratorInAnyProduct }),
+        ...(isDefined(isCollaborator?.wov) && { "Is Collaborator - Officevibe": isCollaborator.wov }),
+        ...(isDefined(isCollaborator?.lms) && { "Is Collaborator - LMS": isCollaborator.lms }),
+        ...(isDefined(isCollaborator?.onb) && { "Is Collaborator - Onboarding": isCollaborator.onb }),
+        ...(isDefined(isCollaborator?.sks) && { "Is Collaborator - Skills": isCollaborator.sks }),
+        ...(isDefined(isCollaborator?.wpm) && { "Is Collaborator - Performance": isCollaborator.wpm }),
+        ...(isDefined(isCollaborator?.pbd) && { "Is Collaborator - Pingboard": isCollaborator.pbd }),
+        ...(isDefined(isReportingManager) && { "Is Reporting Manager": isReportingManager }),
+        ...(isDefined(isTeamManager) && { "Is Team Manager": isTeamManager }),
+        ...(isDefined(planCode?.wov) && { "Plan Code - Officevibe": planCode.wov }),
+        ...(isDefined(planCode?.lms) && { "Plan Code - LMS": planCode.lms }),
+        ...(isDefined(planCode?.onb) && { "Plan Code - Onboarding": planCode.onb }),
+        ...(isDefined(planCode?.sks) && { "Plan Code - Skills": planCode.sks }),
+        ...(isDefined(planCode?.wpm) && { "Plan Code - Performance": planCode.wpm }),
+        ...(isDefined(planCode?.pbd) && { "Plan Code - Pingboard": planCode.pbd })
+    } satisfies LogRocketUserTraits;
+}

package/src/createRequestSanitizer.ts

@@ -0,0 +1,19 @@
+import type { LogRocketRequest } from "./logRocketTypes.ts";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type RequestSanitizerFunction = (req: LogRocketRequest) => any;
+
+export function createRequestSanitizer(fuzzyRequestSanitizer: RequestSanitizerFunction) {
+    return (req: LogRocketRequest) => {
+        if (req.headers["Authorization"]) {
+            req.headers["Authorization"] = "**redacted**";
+        }
+
+        if (req.body) {
+            // Do not return the request body, which could contain sensitive information.
+            req.body = "**redacted**";
+        }
+
+        return fuzzyRequestSanitizer(req);
+    };
+}

package/src/createResponseSanitizer.ts

@@ -0,0 +1,15 @@
+import type { LogRocketResponse } from "./logRocketTypes.ts";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ResponseSanitizerFunction = (res: LogRocketResponse) => any;
+
+export function createResponseSanitizer(fuzzyResponseSanitizer: ResponseSanitizerFunction) {
+    return (res: LogRocketResponse) => {
+        if (res.body) {
+            // Do not return the response body, which could contain sensitive information.
+            res.body = "**redacted**";
+        }
+
+        return fuzzyResponseSanitizer(res);
+    };
+}

package/src/createUrlSanitizer.ts

@@ -0,0 +1,11 @@
+export function createUrlSanitizer(queryParametersToRemove: string[]) {
+    return (url: string) => {
+        let sanitizedUrl = url;
+
+        for (const x of queryParametersToRemove) {
+            sanitizedUrl = sanitizedUrl.replace(new RegExp(`${x}=([^&]*)`, "i"), `${x}=**redacted**`);
+        }
+
+        return sanitizedUrl;
+    };
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export type { LogRocketSdkOptionsTransformer } from "./applyTransformers.ts";
+export { createDefaultUserTraits, type LogRocketIdentification, type LogRocketUserTraits } from "./createDefaultUserTraits.ts";
+export type * from "./logRocketTypes.ts";
+export { registerLogRocketInstrumentation } from "./registerLogRocketInstrumentation.ts";
+

package/src/logRocketTypes.ts

@@ -0,0 +1,30 @@
+import type LogRocket from "logrocket";
+
+// Typings are not exposed by the library.
+export type LogRocketSdkOptions = NonNullable<Parameters<(typeof LogRocket)["init"]>[1]>;
+
+// Typings are not exposed by the library, copied from the LogRocket package.
+export interface LogRocketRequest {
+    reqId: string;
+    url: string;
+    headers: {
+        [key: string]: string | null | undefined;
+    };
+    body?: string;
+    method: string;
+    referrer?: string;
+    mode?: string;
+    credentials?: string;
+}
+
+// Typings are not exposed by the library, copied from the LogRocket package.
+export interface LogRocketResponse {
+    reqId: string;
+    status?: number;
+    headers: {
+        [key: string]: string | null | undefined;
+    };
+    body?: string;
+    method: string;
+    url?: string;
+}