react-marketing-tools 0.4.3 → 1.0.0-alpha.0

package/dist/analytics/analyticsEventService.d.ts

@@ -0,0 +1,13 @@
+import { TrackAnalyticsEventOptions } from '../types/index.js';
+/**
+ *
+ * @paramType {object} options
+ * @property {object} data this is an object of any data you want to collect in analytics
+ * @property {object} eventNameInfo
+ * @property {string} analyticsType
+ * @property {array | undefined} userDataKeysToHashArray default for this value is null, when used it should include an array of strings you wish to hash.
+ * @property {boolean} dataLayerCheck
+ * @property {object} consoleLogData (optional) is an object with the following attributes, "showGlobalVars", "showJourneyPropsPayload", "showUserProps" if any of the values are true you will be able to see the respective payload in your console.
+ */
+declare const trackAnalyticsEvent: (options: TrackAnalyticsEventOptions) => Promise<void>;
+export { trackAnalyticsEvent };

package/dist/analytics/ga4GoogleAnalyticsEventTracking.d.ts

@@ -0,0 +1,3 @@
+import { Ga4GoogleAnalyticsEventTracking } from '../types';
+declare const ga4GoogleAnalyticsEventTracking: (options: Ga4GoogleAnalyticsEventTracking) => Promise<void>;
+export default ga4GoogleAnalyticsEventTracking;

package/dist/analytics/handleDataLayerPush.d.ts

@@ -0,0 +1,3 @@
+import { HandleDataLayerPushOptions } from '../types';
+declare const handleDataLayerPush: (options: HandleDataLayerPushOptions) => Promise<void>;
+export default handleDataLayerPush;

package/dist/analytics/helpers.d.ts

@@ -0,0 +1,41 @@
+import DeviceDetector from 'device-detector-js';
+import { AllowedTypes, EventNameInfo } from '../types';
+/**
+ *
+ * @param {object} user the structure of this data is dictated by you, aka your API or DB.
+ * @param {[string]} includeUserKeys is an array of strings that represent keys from your user data that you want to whitelist, the value for each key in the whitelist will be hashed.
+ * @returns a new user object with all values hashed including only the whitelisted key value pairs
+ */
+export declare const hashUserData: (user: Record<AllowedTypes, AllowedTypes>, includeUserKeys: Array<string>) => Promise<Record<AllowedTypes, AllowedTypes>>;
+/**
+ *
+ * @param {object} user the structure of this data is dictated by you, aka your API or DB.
+ * @param {[string]} includeUserKeys is an array of strings that represent keys from your user data that you want to map over, if no keys are supplied the original passed in user data is returned.
+ * @param {boolean} showMissingUserAttributesInConsole a boolean condition to show or hide "user" attributes that are not included in the "includeUserKeys" array, by console logging in dev tools.
+ * @returns If no "includeUserKeys" are supplied the original ser object is returned, otherwise, a new user object with only the key value pairs that you included in your includeUserKeys array is returned.
+ */
+export declare const buildNewUserData: (user: Record<AllowedTypes, AllowedTypes>, includeUserKeys: Array<string>, showMissingUserAttributesInConsole: boolean | undefined) => Record<string, string>;
+/**
+ *
+ * @paramType {Object} eventNameInfo
+ * @property {analyticsPrefixActionList} actionPrefix either a built in value of JOURNEY | INTERACTION or a custom value added to the analyticsPrefixActionList object.
+ * @property {string} description an OPTIONAL value passed in that is formatted like the following from 'Very descriptive description' to VERY_DESCRIPTIVE_DESCRIPTION.
+ * @property {string} globalAppEvent the current event name for this track event selected from the analyticsGlobalEventActionList
+ * @property {string} previousGlobalAppEvent an OPTIONAL value, the previous event name for this track event selected from the analyticsGlobalEventActionList.
+ * @returns string eventName for this specific tracked event
+ */
+export declare const buildAnalyticsEventName: (eventNameInfo: EventNameInfo) => string;
+/**
+ *
+ * @param {object} data
+ * @param {string} globalAppEvent
+ * @returns dataObject
+ */
+export declare const buildEventDataObject: (data: Record<AllowedTypes, AllowedTypes>, globalAppEvent: string) => Promise<Record<AllowedTypes, AllowedTypes>>;
+/**
+ *
+ * @param {string} eventName
+ * @returns a Boolean value, true if the event name is already in the dataLayer.
+ */
+export declare const defaultDataLayerEventCheck: (eventName: string) => boolean;
+export declare const deviceDetectorInfo: (userAgent: string) => DeviceDetector.DeviceDetectorResult;

package/dist/buildConfig/index.d.ts

@@ -0,0 +1,8 @@
+import { BuildConfigOptions, Config, AnalyticsPlatform } from '../types/index.js';
+declare const analyticsPlatform: AnalyticsPlatform;
+declare const showMeBuildInAnalyticsPlatform: () => void;
+declare const showMeBuildInEventActionPrefixList: () => void;
+declare const showMeBuildInGlobalEventActionList: () => void;
+declare let config: Config;
+declare const buildConfig: (options: BuildConfigOptions) => void;
+export { config, analyticsPlatform, buildConfig, showMeBuildInAnalyticsPlatform, showMeBuildInGlobalEventActionList, showMeBuildInEventActionPrefixList, };

package/dist/core/createAnalytics.d.ts

@@ -0,0 +1,6 @@
+import type { Analytics, AnalyticsConfig } from './types.js';
+/**
+ * Creates an analytics instance. It has no side effects until `start()`, so it is safe to create at module scope and
+ * during server rendering.
+ */
+export declare const createAnalytics: (config: AnalyticsConfig) => Analytics;

package/dist/core/types.d.ts

@@ -0,0 +1,39 @@
+export type ConsentStatus = 'granted' | 'denied';
+/** Event parameters, passed to every destination as-is. */
+export type EventParams = Record<string, unknown>;
+export type AnalyticsEvent = {
+    name: string;
+    params: EventParams;
+    /** Unique per `track()` call and shared by every destination, so vendors can deduplicate the same event. */
+    eventId: string;
+    /** Milliseconds since the Unix epoch at the moment `track()` was called. */
+    timestamp: number;
+};
+/** Somewhere events are sent. Built-in destinations are configured by key; custom ones go in `destinations`. */
+export type Destination = {
+    name: string;
+    /** Called once, in the browser, by `analytics.start()`. */
+    start(): void;
+    track(event: AnalyticsEvent): void;
+};
+export type GtmConfig = {
+    /** Google Tag Manager container ID, e.g. `GTM-XXXXXXX`. */
+    containerId: string;
+    /** Set to `false` when the page already includes the GTM snippet. Defaults to `true`. */
+    loadScript?: boolean;
+};
+export type AnalyticsConfig = {
+    /** Initial consent state. Required, so every site makes an explicit choice. */
+    consent: ConsentStatus;
+    gtm?: GtmConfig;
+    /** Custom destinations, in addition to the built-in ones. */
+    destinations?: Destination[];
+    /** Content-Security-Policy nonce added to every script the library injects. */
+    nonce?: string;
+};
+export type Analytics = {
+    /** Loads vendor scripts and delivers queued events. Safe to call more than once; does nothing outside the browser. */
+    start(): void;
+    /** Sends an event to every destination, queued until `start()`. Does nothing outside the browser. */
+    track(name: string, params?: EventParams): void;
+};

package/dist/core.d.ts

@@ -0,0 +1,2 @@
+export { createAnalytics } from './core/createAnalytics.js';
+export type { Analytics, AnalyticsConfig, AnalyticsEvent, ConsentStatus, Destination, EventParams, GtmConfig, } from './core/types.js';

package/dist/core.js

@@ -0,0 +1,59 @@
+//#region lib/destinations/gtm.ts
+var e = /^GTM-[A-Z0-9]+$/, t = () => window.dataLayer ??= [], n = (e) => Array.from(document.scripts).some((t) => t.src === e), r = ({ src: e, nonce: t }) => {
+	let n = document.createElement("script");
+	n.async = !0, n.src = e, t && n.setAttribute("nonce", t), document.head.append(n);
+}, i = ({ containerId: i, loadScript: a = !0, nonce: o }) => {
+	if (!e.test(i)) throw Error(`[react-marketing-tools] gtm.containerId must look like "GTM-XXXXXXX" (received ${JSON.stringify(i)}).`);
+	let s = `https://www.googletagmanager.com/gtm.js?id=${i}`;
+	return {
+		name: "gtm",
+		start() {
+			let e = t();
+			a && !n(s) && (e.push({
+				"gtm.start": Date.now(),
+				event: "gtm.js"
+			}), r({
+				src: s,
+				nonce: o
+			}));
+		},
+		track({ name: e, params: n, eventId: r }) {
+			t().push({
+				...n,
+				event: e,
+				event_id: r
+			});
+		}
+	};
+}, a = () => typeof window < "u", o = () => typeof crypto.randomUUID == "function" ? crypto.randomUUID() : "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (e) => (Number(e) ^ crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(1))[0] & 15 >> Number(e) / 4).toString(16)), s = (e) => {
+	if (e.consent !== "granted" && e.consent !== "denied") throw Error(`[react-marketing-tools] createAnalytics: "consent" must be 'granted' or 'denied' (received ${JSON.stringify(e.consent)}).`);
+}, c = (e) => {
+	s(e);
+	let t = [...e.gtm ? [i({
+		...e.gtm,
+		nonce: e.nonce
+	})] : [], ...e.destinations ?? []], n = [], r = !1, c = (e) => {
+		for (let n of t) n.track(e);
+	};
+	return {
+		start() {
+			if (!r && a()) {
+				r = !0;
+				for (let e of t) e.start();
+				n.splice(0).forEach(c);
+			}
+		},
+		track(e, t = {}) {
+			if (!a()) return;
+			let i = {
+				name: e,
+				params: t,
+				eventId: o(),
+				timestamp: Date.now()
+			};
+			r ? c(i) : n.push(i);
+		}
+	};
+};
+//#endregion
+export { c as createAnalytics };

package/dist/destinations/gtm.d.ts

@@ -0,0 +1,6 @@
+import type { Destination, GtmConfig } from '../core/types.js';
+type GtmDestinationOptions = GtmConfig & {
+    nonce?: string;
+};
+export declare const createGtmDestination: ({ containerId, loadScript, nonce, }: GtmDestinationOptions) => Destination;
+export {};

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { ReactNode, Context } from 'react';
-import type { ProviderStateProps, ProviderApiProps } from './types';
-export type { Event, GooglePayload, EventNameInfo, AllowedTypes, TrackAnalyticsEventOptions, GlobalVars, DataLayer, ConsoleLogData, AnalyticsTrackerDataOptions, HandleDataLayerPushOptions, ServerLocationData, IpInfo, Ga4GoogleAnalyticsEventTracking, Platform, AnalyticsPlatform, Tokens, Config, BuildConfigOptions, ProviderStateProps, ProviderApiProps, AnalyticsEventActionPrefix, AnalyticsGlobalEventAction, } from './types';
-export { config, analyticsPlatform, buildConfig, showMeBuildInAnalyticsPlatform, showMeBuildInGlobalEventActionList, showMeBuildInEventActionPrefixList, } from './buildConfig';
-export { trackAnalyticsEvent } from './analytics/analyticsEventService';
+import { ReactElement, ReactNode, Context } from 'react';
+import type { ProviderStateProps, ProviderApiProps } from './types/index.js';
+export type { Event, GooglePayload, EventNameInfo, AllowedTypes, TrackAnalyticsEventOptions, GlobalVars, DataLayer, ConsoleLogData, AnalyticsTrackerDataOptions, HandleDataLayerPushOptions, ServerLocationData, IpInfo, Ga4GoogleAnalyticsEventTracking, Platform, AnalyticsPlatform, Tokens, Config, BuildConfigOptions, ProviderStateProps, ProviderApiProps, AnalyticsEventActionPrefix, AnalyticsGlobalEventAction, } from './types/index.js';
+export { config, analyticsPlatform, buildConfig, showMeBuildInAnalyticsPlatform, showMeBuildInGlobalEventActionList, showMeBuildInEventActionPrefixList, } from './buildConfig/index.js';
+export { trackAnalyticsEvent } from './analytics/analyticsEventService.js';
 export declare const ContextState: Context<ProviderStateProps>;
 export declare const ContextApi: Context<ProviderApiProps>;
 type ReactMarketingProviderProps = {
     children: ReactNode;
 };
-export declare const ReactMarketingProvider: ({ children, }: ReactMarketingProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ReactMarketingProvider: ({ children, }: ReactMarketingProviderProps) => ReactElement;
 /**
  * @property {string} appName
  * @property {string} appSessionCookieName