@useblu/blu-lytics 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BLU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+<h1 align="center">
+  <img alt="blu-lytics" src="https://github.com/Pagnet/blu-lytics/assets/102989712/7d06f590-85c6-4373-bec5-c672aa46a68b">
+</h1>
+
+
+## How it works
+Main goals include: being the sole entry point, simplifying integration between monitoring tools, and enabling centralized sending of messages and events.
+These goals offer developers the following benefits:
+
+- **Unified messages and events** <br>
+  Allows messages and events to be propagated across all monitoring tools through a single entry point.
+
+- **Centralized and simplified configuration (Zero config)** <br>
+  Enables initializing tools by providing only their key or token, without the need for prior configuration, saving time and reducing code.
+
+- **Scalability** <br>
+  Facilitates the removal or addition of a tool, as the library contains all necessary configuration for operation. Flexibility that enhances the efficiency of monitoring tool management.
+
+
+## Installation
+```sh
+yarn add @useblu/blu-lytics
+```
+or
+```sh
+npm i @useblu/blu-lytics
+```
+## Usage
+### Importing Library
+
+#### Destructuring the import
+```js
+
+import { initializeProviders } from ‘blu-lytics’;
+
+```
+#### Importing all functionalities
+```js
+
+import * as blu-lytics from ‘blu-lytics’;
+
+```
+
+### Method: `initializeProviders`
+This method simplifies the connection to one or more monitoring tools, eliminating the need for pre-configurations. Simply provide the name of the tool to be used and its API key 'apiKey'.
+
+To establish a connection with a single tool, it is necessary to pass an object as a parameter, containing the fields providerName, apiKey, and another object with the environment (the latter is optional, with the default value being 'production').
+```js
+initializeProviders({providerName: 'track-tool-name', apiKey: 'your-api-key'}, {environment: ‘development’});
+```
+
+To connect to more than one tool, it is necessary to pass an array (list) of objects as a parameter, maintaining the fields providerName, apiKey, and another object containing environment (optional).
+```js
+initializeProviders([
+    { providerName: 'track-tool-name', apiKey: 'your-api-key'},
+    { providerName: 'another-track-tool-name', apiKey: 'your-api-key'}
+], {environment: ‘development’});
+```
+
+### Method: `sendScreenEvent`
+This method sends a message that will be propagated and recorded in all tools that have been previously initialized through the initializeProviders method. To use it, only a string needs to be provided as a parameter.
+```js
+sendScreenEvent(‘page_view’);
+```
+
+### Method: `sendCustomEvent`
+This method sends an event with a message and additional optional parameters, which will be propagated and recorded in all tools that have been previously initialized through the initializeProviders method.
+
+To use it, two parameters need to be provided: a string to describe the event and an object containing the additional optional fields.
+```js
+sendCustomEvent('your_custom_page', {
+    props1: 'any-information',
+    props2: true,
+  });
+```
+
+### Method: `sendUserIdentification`
+This method sends relevant information related to user identification, such as their name, email, and ID, for example.
+
+To use, it is possible to provide two parameters: a string representing a unique identifier and an object containing additional and optional fields.
+```js
+sendUserIdentification('user-id', {
+    name: 'user name',
+    email: 'user@email.com',
+  });
+```
+
+## Supported tracking tools
+- Sentry
+- Fullstory
+- Mixpanel
+
+## Incoming Updates
+### - Suport for Microsoft Clarity
+
+## Contributing
+Whether you're helping us fix bugs, improve the docs, or spread the word, we'd love to have you as part of this project! Read below to learn how you can take part of it.
+### Code of Conduct
+We adopted a Code of Conduct that we expect project participants to adhere to. Please read [the full text](.github/CODE_OF_CONDUCT.md) so that you can understand what actions will and will not be tolerated.
+### Contributing Guide
+Read our [contributing guide](.github/CONTRIBUTING.md) to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes.
+### Release to NPM
+To release a new version on NPM registry, just bump version on *`package.json`* and merge it into master to automatically publish a new version.
+## License
+All packages are licensed under the terms of the MIT License.

package/lib/dispatchers/dispatchers.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dispatchers.spec.d.ts.map

package/lib/dispatchers/dispatchers.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchers.spec.d.ts","sourceRoot":"","sources":["../../src/dispatchers/dispatchers.spec.ts"],"names":[],"mappings":""}

package/lib/dispatchers/dispatchers.spec.js

@@ -0,0 +1,36 @@
+import { sendCustomEvent, sendScreenEvent, sendUserIdentification, } from './index';
+jest.mock('../initializers', function () { return ({
+    userSelectedEnvironment: 'development'
+}); });
+jest.mock('../providers', function () { return ({
+    providersList: [
+        {
+            screenEvent: jest.fn(),
+            customEvent: jest.fn(),
+            userIdentification: jest.fn()
+        },
+    ]
+}); });
+jest.mock('../utils', function () { return ({
+    isValidProvidersList: jest.fn(function () { return true; })
+}); });
+describe('Event dispatching functions', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('should be dispatch sendScreenEvent', function () {
+        var consoleLogSpy = jest.spyOn(console, 'log');
+        sendScreenEvent('TestScreen');
+        expect(consoleLogSpy).toHaveBeenCalledWith('[BLUEFIN]: Screen event: TestScreen');
+    });
+    it('should be dispatch sendCustomEvent', function () {
+        var consoleLogSpy = jest.spyOn(console, 'log');
+        sendCustomEvent('TestEvent', { prop1: 'value1' });
+        expect(consoleLogSpy).toHaveBeenCalledWith('[BLUEFIN]: Custom event: TestEvent - {"prop1":"value1"}');
+    });
+    it('should be dispatch sendUserIdentification', function () {
+        var consoleLogSpy = jest.spyOn(console, 'log');
+        sendUserIdentification('123', { name: 'Name' });
+        expect(consoleLogSpy).toHaveBeenCalledWith('[BLUEFIN]: User identification: 123 - {"name":"Name"}');
+    });
+});

package/lib/dispatchers/dispatchers.types.d.ts

@@ -0,0 +1,17 @@
+export type EventType = 'customEvent' | 'screenEvent' | 'userIdentification';
+export type PropertiesType = {
+    [key: string]: string;
+};
+export type UserPropertiesType = {
+    email?: string;
+    name?: string;
+    [key: string]: string | undefined;
+};
+export type EventData = {
+    screen?: string;
+    properties?: PropertiesType;
+    event?: string;
+    id?: string;
+    userProperties?: UserPropertiesType;
+};
+//# sourceMappingURL=dispatchers.types.d.ts.map

package/lib/dispatchers/dispatchers.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchers.types.d.ts","sourceRoot":"","sources":["../../src/dispatchers/dispatchers.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,aAAa,GAAG,oBAAoB,CAAC;AAC7E,MAAM,MAAM,cAAc,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AACvD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,cAAc,CAAC,EAAE,kBAAkB,CAAC;CACrC,CAAC"}

package/lib/dispatchers/dispatchers.types.js

@@ -0,0 +1 @@
+export {};

package/lib/dispatchers/index.d.ts

@@ -0,0 +1,13 @@
+import { EventData, PropertiesType, UserPropertiesType } from './dispatchers.types';
+/**
+ * Dispatches the specified event data to all configured providers.
+ *
+ * @param {EventData} eventData - The data associated with the event to be dispatched.
+ * @returns {void}
+ */
+export declare const dispatchEventToAllProviders: (eventData: EventData) => void;
+declare const sendScreenEvent: (screen: string) => void;
+declare const sendCustomEvent: (event: string, properties: PropertiesType) => void;
+declare const sendUserIdentification: (id: string, userProperties: UserPropertiesType) => void;
+export { sendCustomEvent, sendScreenEvent, sendUserIdentification };
+//# sourceMappingURL=index.d.ts.map

package/lib/dispatchers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dispatchers/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEpF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,cAAe,SAAS,KAAG,IAsBlE,CAAC;AAEF,QAAA,MAAM,eAAe,WAAY,MAAM,KAAG,IAMzC,CAAC;AAEF,QAAA,MAAM,eAAe,UAAW,MAAM,cAAc,cAAc,KAAG,IAQpE,CAAC;AAEF,QAAA,MAAM,sBAAsB,OACtB,MAAM,kBACM,kBAAkB,KACjC,IAQF,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC"}

package/lib/dispatchers/index.js

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { userSelectedEnvironment } from '../initializers';
+import { providersList } from '../providers';
+import { isValidProvidersList } from '../utils';
+/**
+ * Dispatches the specified event data to all configured providers.
+ *
+ * @param {EventData} eventData - The data associated with the event to be dispatched.
+ * @returns {void}
+ */
+export var dispatchEventToAllProviders = function (eventData) {
+    if (!isValidProvidersList(providersList)) {
+        return;
+    }
+    providersList.forEach(function (provider) {
+        var actions = {
+            screenEvent: function () { return provider.screenEvent
+                && eventData.screen
+                && provider.screenEvent(eventData.screen); },
+            customEvent: function () { return provider.customEvent
+                && eventData.event
+                && eventData.properties
+                && provider.customEvent(eventData.event, eventData.properties); },
+            userIdentification: function () { return provider.userIdentification
+                && eventData.id
+                && eventData.userProperties
+                && provider.userIdentification(eventData.id, eventData.userProperties); }
+        };
+        Object.values(actions).forEach(function (action) { return action(); });
+    });
+};
+var sendScreenEvent = function (screen) {
+    if (userSelectedEnvironment === 'development') {
+        console.log("[BLUEFIN]: Screen event: ".concat(screen));
+    }
+    else {
+        dispatchEventToAllProviders({ screen: screen });
+    }
+};
+var sendCustomEvent = function (event, properties) {
+    if (userSelectedEnvironment === 'development') {
+        console.log("[BLUEFIN]: Custom event: ".concat(event, " - ").concat(JSON.stringify(properties)));
+    }
+    else {
+        dispatchEventToAllProviders({ event: event, properties: properties });
+    }
+};
+var sendUserIdentification = function (id, userProperties) {
+    if (userSelectedEnvironment === 'development') {
+        console.log("[BLUEFIN]: User identification: ".concat(id, " - ").concat(JSON.stringify(userProperties)));
+    }
+    else {
+        dispatchEventToAllProviders({ id: id, userProperties: userProperties });
+    }
+};
+export { sendCustomEvent, sendScreenEvent, sendUserIdentification };

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { initializeProviders } from './initializers';
+export { sendCustomEvent, sendScreenEvent, sendUserIdentification } from './dispatchers';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}

package/lib/index.js

@@ -0,0 +1,2 @@
+export { initializeProviders } from './initializers';
+export { sendCustomEvent, sendScreenEvent, sendUserIdentification } from './dispatchers';

package/lib/initializers/index.d.ts

@@ -0,0 +1,21 @@
+import { IInitializeParams, EnvironmentType } from './initializers.types';
+/**
+ * Represents the current environment setting for providers.
+ * @type {EnvironmentType}
+ * @description This variable stores the current environment setting
+ *              used by providers. It is initially undefined and
+ *              gets updated when the `initializeProviders` function is called.
+ *              Make sure to call `initializeProviders` before accessing this value.
+ */
+declare let userSelectedEnvironment: EnvironmentType;
+/**
+ * Initializes error tracking providers based on the given parameters.
+ * @param {IInitializeParams | IInitializeParams[]} paramsArray - Parameters for initialization.
+ * @options {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @returns {void}
+ */
+export declare const initializeProviders: (paramsArray: IInitializeParams | IInitializeParams[], options?: {
+    environment: EnvironmentType;
+}) => void;
+export { userSelectedEnvironment };
+//# sourceMappingURL=index.d.ts.map

package/lib/initializers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/initializers/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AA+F1E;;;;;;;GAOG;AACH,QAAA,IAAI,uBAAuB,EAAE,eAAe,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,gBACjB,iBAAiB,GAAG,iBAAiB,EAAE;iBAC5B,eAAe;MACtC,IAwCF,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/lib/initializers/index.js

@@ -0,0 +1,130 @@
+/* eslint-disable import/no-mutable-exports */
+import * as Sentry from '@sentry/react';
+import { init } from '@fullstory/browser';
+import mixpanel from 'mixpanel-browser';
+import { BrowserTracing } from '@sentry/tracing';
+import { CaptureConsole } from '@sentry/integrations';
+import { clarity } from 'react-microsoft-clarity';
+/**
+ * Checks if the environment is set to 'production'.
+ * @param {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @returns {boolean} - True if the environment is 'production', false otherwise.
+ */
+var isProduction = function (environment) { return environment === 'production'; };
+/**
+ * Initializes Microsoft Clarity for error tracking in a web environment.
+ * @param {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @param {string} id - The Clarity project id.
+ * @returns {void}
+ */
+var clarityInitializer = function (environment, apiKey) {
+    if (isProduction(environment))
+        clarity.init(apiKey);
+};
+/**
+ * Initializes FullStory for error tracking in a web environment.
+ * @param {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @param {string} orgId - The FullStory organization ID.
+ * @returns {void}
+ */
+var fullStoryInitializer = function (environment, apiKey) {
+    if (isProduction(environment))
+        init({ orgId: apiKey });
+};
+/**
+ * Initializes MixPanel for error tracking in a web environment.
+ * @param {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @param {string} credential - The MixPanel project token.
+ * @returns {void}
+ */
+var mixPanelInitializer = function (environment, apiKey) {
+    if (isProduction(environment)) {
+        mixpanel.init(apiKey, {
+            track_pageview: true,
+            persistence: 'localStorage'
+        });
+    }
+};
+/**
+ * Initializes Sentry for error tracking in a web environment.
+ * @param {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @param {string} dsn - The Sentry DSN (Data Source Name).
+ * @param {number} tracesSampleRate - The percentage of transactions to be sampled (0 to 1).
+ * @returns {void}
+ */
+var sentryInitializer = function (environment, apiKey, tracesSampleRate) {
+    if (tracesSampleRate === void 0) { tracesSampleRate = 0.5; }
+    if (!isProduction(environment)) {
+        return;
+    }
+    if (tracesSampleRate < 0 || tracesSampleRate > 1) {
+        throw new Error('tracesSampleRate must be in the range [0, 1]');
+    }
+    Sentry.init({
+        dsn: apiKey,
+        integrations: [
+            new BrowserTracing(),
+            new CaptureConsole({
+                levels: ['warn', 'error']
+            }),
+        ],
+        environment: environment,
+        tracesSampleRate: tracesSampleRate,
+        initialScope: {
+            tags: {
+                environment: environment
+            }
+        }
+    });
+};
+/**
+ * Represents the current environment setting for providers.
+ * @type {EnvironmentType}
+ * @description This variable stores the current environment setting
+ *              used by providers. It is initially undefined and
+ *              gets updated when the `initializeProviders` function is called.
+ *              Make sure to call `initializeProviders` before accessing this value.
+ */
+var userSelectedEnvironment;
+/**
+ * Initializes error tracking providers based on the given parameters.
+ * @param {IInitializeParams | IInitializeParams[]} paramsArray - Parameters for initialization.
+ * @options {EnvironmentType} environment - The environment (e.g., 'production', 'development').
+ * @returns {void}
+ */
+export var initializeProviders = function (paramsArray, options) {
+    if (options === void 0) { options = { environment: 'production' }; }
+    var environment = options.environment;
+    var initializedProviders = [];
+    var initialize = function (params) {
+        var providerName = params.providerName, _a = params.tracesSampleRate, tracesSampleRate = _a === void 0 ? 0.1 : _a, _b = params.apiKey, apiKey = _b === void 0 ? '' : _b;
+        switch (providerName) {
+            case 'Clarity':
+                clarityInitializer(environment, apiKey);
+                break;
+            case 'FullStory':
+                fullStoryInitializer(environment, apiKey);
+                break;
+            case 'Sentry':
+                sentryInitializer(environment, apiKey, tracesSampleRate);
+                break;
+            case 'MixPanel':
+                mixPanelInitializer(environment, apiKey);
+                break;
+            default:
+                break;
+        }
+        initializedProviders.push(providerName);
+    };
+    userSelectedEnvironment = environment;
+    if (Array.isArray(paramsArray)) {
+        paramsArray.forEach(initialize);
+    }
+    else {
+        initialize(paramsArray);
+    }
+    if (initializedProviders.length > 0) {
+        console.log('[Bluefin] Initialized providers:', initializedProviders);
+    }
+};
+export { userSelectedEnvironment };

package/lib/initializers/initializers.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=initializers.spec.d.ts.map

package/lib/initializers/initializers.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializers.spec.d.ts","sourceRoot":"","sources":["../../src/initializers/initializers.spec.ts"],"names":[],"mappings":""}

package/lib/initializers/initializers.spec.js

@@ -0,0 +1,39 @@
+import { initializeProviders, userSelectedEnvironment, } from './index';
+jest.mock('@sentry/react', function () { return ({
+    init: jest.fn()
+}); });
+jest.mock('mixpanel-browser', function () { return ({
+    init: jest.fn()
+}); });
+describe('Initializers', function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+    });
+    describe('initializeProviders', function () {
+        it('should initialize providers and update userSelectedEnvironment', function () {
+            var paramsArray = [{ providerName: 'Mixpanel', apiKey: 'your-api-key' }, { providerName: 'Sentry', apiKey: 'your-api-key' }];
+            var logSpy = jest.spyOn(console, 'log').mockImplementation(function () { });
+            initializeProviders(paramsArray, { environment: 'production' });
+            expect(userSelectedEnvironment).toBe('production');
+            expect(logSpy).toHaveBeenCalledWith('[Bluefin] Initialized providers:', expect.arrayContaining(['Mixpanel', 'Sentry']));
+            logSpy.mockRestore();
+        });
+        it('should throw an error when initializing Sentry with an invalid tracesSampleRate', function () {
+            var paramsArray = [
+                { providerName: 'Sentry', apiKey: 'your-api-key', tracesSampleRate: 1.5 },
+            ];
+            expect(function () { return initializeProviders(paramsArray, { environment: 'production' }); }).toThrow('tracesSampleRate must be in the range [0, 1]');
+        });
+        it('should not throw an error when initializing Sentry with a valid tracesSampleRate', function () {
+            var validParams = [
+                { providerName: 'Sentry', apiKey: 'your-api-key', tracesSampleRate: 0.5 },
+            ];
+            expect(function () { return initializeProviders(validParams, { environment: 'production' }); }).not.toThrow();
+        });
+        it('should default to "production" environment if not specified in parameters', function () {
+            var paramsArray = { providerName: 'Sentry', apiKey: 'your-api-key' };
+            initializeProviders(paramsArray);
+            expect(userSelectedEnvironment).toEqual('production');
+        });
+    });
+});

package/lib/initializers/initializers.types.d.ts

@@ -0,0 +1,8 @@
+export type ProviderNameType = 'Clarity' | 'Sentry' | 'FullStory' | 'MixPanel' | 'Firebase';
+export type EnvironmentType = 'development' | 'staging' | 'production';
+export interface IInitializeParams {
+    providerName: ProviderNameType;
+    tracesSampleRate?: number;
+    apiKey?: string;
+}
+//# sourceMappingURL=initializers.types.d.ts.map

package/lib/initializers/initializers.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializers.types.d.ts","sourceRoot":"","sources":["../../src/initializers/initializers.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;AAE5F,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/lib/initializers/initializers.types.js

@@ -0,0 +1 @@
+export {};

package/lib/providers/index.d.ts

@@ -0,0 +1,13 @@
+import { ProviderType } from './provider.types';
+/**
+ * An array containing the list of providers, initialized with the default provider(s).
+ */
+declare const providersList: ProviderType[];
+/**
+ * Adds or updates a provider in the providers list.
+ *
+ * @param provider - The provider to be added or updated.
+ */
+declare const setup: (provider: ProviderType) => void;
+export { providersList, setup };
+//# sourceMappingURL=index.d.ts.map

package/lib/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAchD;;GAEG;AACH,QAAA,MAAM,aAAa,EAAE,YAAY,EAA0B,CAAC;AAE5D;;;;GAIG;AACH,QAAA,MAAM,KAAK,aAAc,YAAY,KAAG,IAUvC,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC"}

package/lib/providers/index.js

@@ -0,0 +1,39 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import SentryProvider from './setups/sentry/sentry';
+import MixPanelProvider from './setups/mixpanel/mixpanel';
+import FullStoryProvider from './setups/fullstory/fullstory';
+/**
+ * An array containing the default provider(s).
+ */
+var providersDefault = [
+    SentryProvider,
+    MixPanelProvider,
+    FullStoryProvider,
+];
+/**
+ * An array containing the list of providers, initialized with the default provider(s).
+ */
+var providersList = __spreadArray([], providersDefault, true);
+/**
+ * Adds or updates a provider in the providers list.
+ *
+ * @param provider - The provider to be added or updated.
+ */
+var setup = function (provider) {
+    var existingIndex = providersList.findIndex(function (existingProvider) { return existingProvider.name === provider.name; });
+    if (existingIndex !== -1) {
+        providersList[existingIndex] = provider;
+    }
+    else {
+        providersList.unshift(provider);
+    }
+};
+export { providersList, setup };

package/lib/providers/provider.types.d.ts

@@ -0,0 +1,8 @@
+import { PropertiesType } from '../dispatchers/dispatchers.types';
+export type ProviderType = {
+    name: 'Clarity' | 'Sentry' | 'FullStory' | 'MixPanel';
+    userIdentification: (id: string, userProperties: any) => void;
+    customEvent: (event: string, properties: PropertiesType) => void;
+    screenEvent: (screen: string) => void;
+};
+//# sourceMappingURL=provider.types.d.ts.map

package/lib/providers/provider.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.types.d.ts","sourceRoot":"","sources":["../../src/providers/provider.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAElE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAE;IACvD,kBAAkB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,KAAK,IAAI,CAAC;IAC9D,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,KAAK,IAAI,CAAC;IACjE,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC"}

package/lib/providers/provider.types.js

@@ -0,0 +1 @@
+export {};

package/lib/providers/setups/clarity/clarity.d.ts

@@ -0,0 +1,4 @@
+import { ProviderType } from '../../provider.types';
+declare const ClarityProvider: ProviderType;
+export default ClarityProvider;
+//# sourceMappingURL=clarity.d.ts.map

package/lib/providers/setups/clarity/clarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clarity.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/clarity/clarity.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA0BpD,QAAA,MAAM,eAAe,EAAE,YAKtB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/lib/providers/setups/clarity/clarity.js

@@ -0,0 +1,17 @@
+import { clarity } from 'react-microsoft-clarity';
+var dispatchUserIdentification = function (id, userProperties) {
+    clarity.identify(id, { userProperties: userProperties });
+};
+var dispatchCustomEvent = function (event, properties) {
+    clarity.setTag(event, 'customEvent');
+};
+var dispatchScreenEvent = function (screen) {
+    clarity.setTag(screen, 'screen');
+};
+var ClarityProvider = {
+    name: 'Clarity',
+    userIdentification: dispatchUserIdentification,
+    customEvent: dispatchCustomEvent,
+    screenEvent: dispatchScreenEvent
+};
+export default ClarityProvider;

package/lib/providers/setups/fullstory/fullstory.d.ts

@@ -0,0 +1,4 @@
+import { ProviderType } from '../../provider.types';
+declare const FullStoryProvider: ProviderType;
+export default FullStoryProvider;
+//# sourceMappingURL=fullstory.d.ts.map

package/lib/providers/setups/fullstory/fullstory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullstory.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/fullstory/fullstory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA2BpD,QAAA,MAAM,iBAAiB,EAAE,YAKxB,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/lib/providers/setups/fullstory/fullstory.js

@@ -0,0 +1,18 @@
+import * as FullStory from '@fullstory/browser';
+var dispatchUserIdentification = function (id, userProperties) {
+    FullStory.identify(id);
+    FullStory.setUserVars(userProperties);
+};
+var dispatchCustomEvent = function (event, properties) {
+    FullStory.event(event, { properties: properties });
+};
+var dispatchScreenEvent = function (screen) {
+    FullStory.event(screen, {});
+};
+var FullStoryProvider = {
+    name: 'FullStory',
+    userIdentification: dispatchUserIdentification,
+    customEvent: dispatchCustomEvent,
+    screenEvent: dispatchScreenEvent
+};
+export default FullStoryProvider;

package/lib/providers/setups/fullstory/fullstory.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fullstory.spec.d.ts.map

package/lib/providers/setups/fullstory/fullstory.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullstory.spec.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/fullstory/fullstory.spec.ts"],"names":[],"mappings":""}

package/lib/providers/setups/fullstory/fullstory.spec.js

@@ -0,0 +1,30 @@
+import * as FullStory from '@fullstory/browser';
+import FullStoryProvider from './fullstory';
+jest.mock('@fullstory/browser', function () { return ({
+    identify: jest.fn(),
+    setUserVars: jest.fn(),
+    event: jest.fn()
+}); });
+describe('FullStoryProvider', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('dispatchUserIdentification should call FullStory.identify and FullStory.setUserVars', function () {
+        var id = '123';
+        var userProperties = { email: 'test@example.com', name: 'Test User' };
+        FullStoryProvider.userIdentification(id, userProperties);
+        expect(FullStory.identify).toHaveBeenCalledWith(id);
+        expect(FullStory.setUserVars).toHaveBeenCalledWith(userProperties);
+    });
+    it('dispatchCustomEvent should call FullStory.event with properties', function () {
+        var event = 'customEvent';
+        var properties = { key: 'value' };
+        FullStoryProvider.customEvent(event, properties);
+        expect(FullStory.event).toHaveBeenCalledWith(event, { properties: properties });
+    });
+    it('dispatchScreenEvent should call FullStory.event with empty properties', function () {
+        var screen = 'testScreen';
+        FullStoryProvider.screenEvent(screen);
+        expect(FullStory.event).toHaveBeenCalledWith(screen, {});
+    });
+});

package/lib/providers/setups/mixpanel/mixpanel.d.ts

@@ -0,0 +1,4 @@
+import { ProviderType } from '../../provider.types';
+declare const MixPanelProvider: ProviderType;
+export default MixPanelProvider;
+//# sourceMappingURL=mixpanel.d.ts.map

package/lib/providers/setups/mixpanel/mixpanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixpanel.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/mixpanel/mixpanel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA0CpD,QAAA,MAAM,gBAAgB,EAAE,YAKvB,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/lib/providers/setups/mixpanel/mixpanel.js

@@ -0,0 +1,35 @@
+import mixpanel from 'mixpanel-browser';
+var dispatchUserIdentification = function (id, userProperties) {
+    mixpanel.identify(id);
+    var superProperties = ['name', 'email'];
+    var peopleProperties = {};
+    var cipherProperty = function (key) {
+        if (userProperties === null || userProperties === void 0 ? void 0 : userProperties[key]) {
+            peopleProperties["$".concat(key)] = userProperties[key];
+        }
+    };
+    superProperties.forEach(cipherProperty);
+    Object.entries(userProperties)
+        .filter(function (_a) {
+        var key = _a[0], value = _a[1];
+        return !superProperties.includes(key) && value;
+    })
+        .forEach(function (_a) {
+        var key = _a[0], value = _a[1];
+        peopleProperties[key] = value;
+    });
+    mixpanel.people.set(peopleProperties);
+};
+var dispatchCustomEvent = function (event, properties) {
+    mixpanel.track(event, { properties: properties });
+};
+var dispatchScreenEvent = function (screen) {
+    mixpanel.track(screen);
+};
+var MixPanelProvider = {
+    name: 'MixPanel',
+    userIdentification: dispatchUserIdentification,
+    customEvent: dispatchCustomEvent,
+    screenEvent: dispatchScreenEvent
+};
+export default MixPanelProvider;

package/lib/providers/setups/mixpanel/mixpanel.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mixpanel.spec.d.ts.map

package/lib/providers/setups/mixpanel/mixpanel.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixpanel.spec.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/mixpanel/mixpanel.spec.ts"],"names":[],"mappings":""}

package/lib/providers/setups/mixpanel/mixpanel.spec.js

@@ -0,0 +1,38 @@
+import mixpanel from 'mixpanel-browser';
+import MixPanelProvider from './mixpanel';
+jest.mock('mixpanel-browser', function () { return ({
+    identify: jest.fn(),
+    track: jest.fn(),
+    people: {
+        set: jest.fn()
+    }
+}); });
+describe('MixPanelProvider', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    test('dispatchUserIdentification should call mixpanel.identify and mixpanel.people.set', function () {
+        var id = 'testUserId';
+        var userProperties = {
+            email: 'test@example.com',
+            name: 'Test User'
+        };
+        MixPanelProvider.userIdentification(id, userProperties);
+        expect(mixpanel.identify).toHaveBeenCalledWith(id);
+        expect(mixpanel.people.set).toHaveBeenCalledWith({
+            $name: 'Test User',
+            $email: 'test@example.com'
+        });
+    });
+    test('dispatchCustomEvent should call mixpanel.track with event and properties', function () {
+        var event = 'testEvent';
+        var properties = { key1: 'value1', key2: 'value2' };
+        MixPanelProvider.customEvent(event, properties);
+        expect(mixpanel.track).toHaveBeenCalledWith(event, { properties: properties });
+    });
+    test('dispatchScreenEvent should call mixpanel.track with screen', function () {
+        var screen = 'testScreen';
+        MixPanelProvider.screenEvent(screen);
+        expect(mixpanel.track).toHaveBeenCalledWith(screen);
+    });
+});

package/lib/providers/setups/sentry/sentry.d.ts

@@ -0,0 +1,4 @@
+import { ProviderType } from '../../provider.types';
+declare const SentryProvider: ProviderType;
+export default SentryProvider;
+//# sourceMappingURL=sentry.d.ts.map

package/lib/providers/setups/sentry/sentry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/sentry/sentry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA6CpD,QAAA,MAAM,cAAc,EAAE,YAKrB,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/lib/providers/setups/sentry/sentry.js

@@ -0,0 +1,42 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import * as Sentry from '@sentry/react';
+var dispatchUserIdentification = function (id, userProperties) {
+    var userSentry = __assign({ id: id, email: userProperties.email || '', username: userProperties.name || '' }, userProperties);
+    Sentry.setUser(userSentry);
+};
+var dispatchCustomEvent = function (event, properties) {
+    var breadcrumb = {
+        category: 'customEvent',
+        message: event,
+        level: Sentry.Severity.Info,
+        data: properties,
+        type: 'info'
+    };
+    Sentry.addBreadcrumb(breadcrumb);
+};
+var dispatchScreenEvent = function (screen) {
+    var breadcrumb = {
+        category: 'screen',
+        message: screen,
+        level: Sentry.Severity.Info,
+        type: 'info'
+    };
+    Sentry.addBreadcrumb(breadcrumb);
+};
+var SentryProvider = {
+    name: 'Sentry',
+    userIdentification: dispatchUserIdentification,
+    customEvent: dispatchCustomEvent,
+    screenEvent: dispatchScreenEvent
+};
+export default SentryProvider;

package/lib/providers/setups/sentry/sentry.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sentry.spec.d.ts.map

package/lib/providers/setups/sentry/sentry.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.spec.d.ts","sourceRoot":"","sources":["../../../../src/providers/setups/sentry/sentry.spec.ts"],"names":[],"mappings":""}

package/lib/providers/setups/sentry/sentry.spec.js

@@ -0,0 +1,56 @@
+import * as Sentry from '@sentry/react';
+import SentryProvider from './sentry';
+jest.mock('@sentry/react', function () { return ({
+    __esModule: true,
+    setUser: jest.fn(),
+    addBreadcrumb: jest.fn(),
+    Severity: {
+        Info: 'info'
+    }
+}); });
+describe('SentryProvider', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('dispatchUserIdentification should set user in Sentry', function () {
+        var userId = '123';
+        var userProperties = {
+            email: 'test@example.com',
+            name: 'Test User',
+            customProperty: 'custom'
+        };
+        SentryProvider.userIdentification(userId, userProperties);
+        expect(Sentry.setUser).toHaveBeenCalledWith({
+            id: userId,
+            email: userProperties.email,
+            username: userProperties.name,
+            name: userProperties.name,
+            customProperty: 'custom'
+        });
+    });
+    it('dispatchCustomEvent should add breadcrumb in Sentry', function () {
+        var eventName = 'customEvent';
+        var properties = {
+            key1: 'value1',
+            key2: 'value2'
+        };
+        SentryProvider.customEvent(eventName, properties);
+        expect(Sentry.addBreadcrumb).toHaveBeenCalledWith({
+            category: 'customEvent',
+            message: eventName,
+            level: 'info',
+            data: properties,
+            type: 'info'
+        });
+    });
+    it('dispatchScreenEvent should add breadcrumb for screen in Sentry', function () {
+        var screenName = 'Home';
+        SentryProvider.screenEvent(screenName);
+        expect(Sentry.addBreadcrumb).toHaveBeenCalledWith({
+            category: 'screen',
+            message: screenName,
+            level: 'info',
+            type: 'info'
+        });
+    });
+});

package/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { ProviderType } from '../providers/provider.types';
+export declare const isValidProvidersList: (providersList: ProviderType[]) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAG3D,eAAO,MAAM,oBAAoB,kBAChB,YAAY,EAAE,KAC5B,OAAmE,CAAC"}

package/lib/utils/index.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export var isValidProvidersList = function (providersList) { return Array.isArray(providersList) && providersList.length > 0; };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@useblu/blu-lytics",
+  "version": "1.0.0",
+  "private": false,
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "engines": {
+    "node": "^16.10.0"
+  },
+  "scripts": {
+    "build": "tsc --declaration",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "test": "TZ=UTC+3 jest",
+    "coverage": "TZ=UTC+3 jest --coverage"
+  },
+  "dependencies": {
+    "@fullstory/browser": "1.7.0",
+    "@sentry/integrations": "^6.19.7",
+    "@sentry/react": "^6.19.7",
+    "@sentry/tracing": "^6.19.7",
+    "jest-environment-jsdom": "^29.7.0",
+    "mixpanel-browser": "^2.48.1",
+    "react": "^18.2.0",
+    "react-microsoft-clarity": "^1.2.0"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/jest": "^29.2.3",
+    "@types/mixpanel-browser": "^2.47.5",
+    "@types/react": "^18.0.25",
+    "@typescript-eslint/eslint-plugin": "^5.43.0",
+    "@typescript-eslint/parser": "^5.43.0",
+    "eslint": "^8.27.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-react": "^7.31.10",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "jest": "^29.2.2",
+    "prettier": "^2.3.2",
+    "ts-jest": "^29.0.3",
+    "ts-node-dev": "^2.0.0",
+    "tsup": "^6.4.0",
+    "typescript": "^4.8.4"
+  },
+  "description": "blu-lytics",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pagnet/blu-lytics.git"
+  },
+  "keywords": [
+    "blu-lytics"
+  ],
+  "author": "Blu",
+  "bugs": {
+    "url": "https://github.com/Pagnet/blu-lytics/issues"
+  },
+  "homepage": "https://github.com/Pagnet/blu-lytics#readme",
+  "files": [
+    "lib/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}