@sitecore-content-sdk/events 2.0.0-canary.12

package/dist/esm/src/eventStorage/eventStorage.js

@@ -0,0 +1,64 @@
+import { language, pageName } from '@sitecore-content-sdk/analytics-core/internal';
+import { CustomEvent } from '../events';
+import { sendEvent } from '../events/send-event/sendEvent';
+class EventQueue {
+    constructor() {
+        /**
+         * Initialize the Event Storage
+         */
+        this.key = 'EventQueue';
+    }
+    /**
+     * Adds the required event data to the queue and stores it in the storage.
+     * @param {QueueEventPayload} queueEventPayload - The required event data for the creation of a `CustomEvent`.
+     * Validates by creating a new `CustomEvent`.
+     */
+    enqueueEvent(queueEventPayload) {
+        var _a, _b;
+        const sessionStorage = this.getSessionStorage();
+        queueEventPayload.eventData.page = (_a = queueEventPayload.eventData.page) !== null && _a !== void 0 ? _a : pageName();
+        queueEventPayload.eventData.language = (_b = queueEventPayload.eventData.language) !== null && _b !== void 0 ? _b : language();
+        new CustomEvent(Object.assign({ sendEvent }, queueEventPayload));
+        const eventQueue = this.getEventQueue();
+        eventQueue.push(queueEventPayload);
+        sessionStorage.setItem(this.key, JSON.stringify(eventQueue));
+    }
+    /**
+     * Iterates the queue and sends sequentially the custom events to Sitecore Edge Proxy.
+     */
+    async sendAllEvents() {
+        const eventQueue = this.getEventQueue();
+        for (const queueEventPayload of eventQueue)
+            await new CustomEvent({
+                eventData: queueEventPayload.eventData,
+                id: queueEventPayload.id,
+                sendEvent,
+                config: queueEventPayload.config,
+            }).send();
+        this.clearQueue();
+    }
+    /**
+     * Clears the queue from storage.
+     */
+    clearQueue() {
+        const sessionStorage = this.getSessionStorage();
+        sessionStorage.removeItem(this.key);
+    }
+    /** Returns the stored array of data with type `QueueEventPayload`, or empty array if the given key does not exist. */
+    getEventQueue() {
+        var _a;
+        const sessionStorage = this.getSessionStorage();
+        const storedQueue = (_a = sessionStorage.getItem(this.key)) !== null && _a !== void 0 ? _a : '""';
+        try {
+            const parsedQueueEvent = JSON.parse(storedQueue);
+            return Array.isArray(parsedQueueEvent) ? parsedQueueEvent : [];
+        }
+        catch (_b) {
+            return [];
+        }
+    }
+    getSessionStorage() {
+        return sessionStorage;
+    }
+}
+export const eventQueue = new EventQueue();

package/dist/esm/src/eventStorage/processEventQueue.js

@@ -0,0 +1,13 @@
+import { getCoreContext } from '@sitecore-content-sdk/core';
+import { eventQueue } from './eventStorage';
+import { getEventsPlugin } from '../initialization/plugin';
+/**
+ * A function that sends all queue events to the SitecoreCloud API.
+ * Clears the queue upon completion.
+ * @public
+ */
+export async function processEventQueue() {
+    await getCoreContext().readyPromise;
+    getEventsPlugin();
+    eventQueue.sendAllEvents();
+}

package/dist/esm/src/events/base-event.js

@@ -0,0 +1,31 @@
+import { language, pageName } from '@sitecore-content-sdk/analytics-core/internal';
+export class BaseEvent {
+    /**
+     * The base event class that has all the shared functions between Events
+     * @param {BaseEventData} baseEventData - The event data to send
+     * @param {string} id - The client id
+     */
+    constructor(baseEventData, id) {
+        var _a, _b;
+        this.baseEventData = baseEventData;
+        this.clientId = id;
+        this.language = (_a = this.baseEventData.language) !== null && _a !== void 0 ? _a : language();
+        this.page = (_b = this.baseEventData.page) !== null && _b !== void 0 ? _b : pageName();
+    }
+    /**
+     *  A function that returns the properties for sending events to the Sitecore Edge Proxy.
+     * @returns an object that is required
+     */
+    mapBaseEventPayload() {
+        return {
+            browser_id: this.clientId,
+            channel: this.baseEventData.channel,
+            client_key: '',
+            currency: this.baseEventData.currency,
+            language: this.language,
+            page: this.page,
+            pos: '',
+            requested_at: new Date().toISOString(),
+        };
+    }
+}

package/dist/esm/src/events/common-interfaces.js

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

package/dist/esm/src/events/consts.js

@@ -0,0 +1,2 @@
+export const MAX_EXT_ATTRIBUTES = 50;
+export const UTM_PREFIX = 'utm_';

package/dist/esm/src/events/custom-event/custom-event.js

@@ -0,0 +1,58 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { flattenObject } from '@sitecore-content-sdk/analytics-core/utils';
+import { BaseEvent } from '../base-event';
+import { MAX_EXT_ATTRIBUTES } from '../consts';
+import { constants } from '@sitecore-content-sdk/core';
+const { ERROR_MESSAGES } = constants;
+/**
+ * A class that extends from {@link BaseEvent} and has all the required functionality to send a custom event
+ * @internal
+ */
+export class CustomEvent extends BaseEvent {
+    /**
+     * A class that extends from {@link BaseEvent} and has all the required functionality to send a custom event
+     * @param {CustomEventArguments} args - Unified object containing the required properties
+     */
+    constructor(args) {
+        const _a = args.eventData, { channel, currency, language, page, type, extensionData, searchData } = _a, rest = __rest(_a, ["channel", "currency", "language", "page", "type", "extensionData", "searchData"]);
+        super({ channel, currency, language, page }, args.id);
+        this.extensionData = {};
+        this.sendEvent = args.sendEvent;
+        this.config = args.config;
+        this.customEventPayload = Object.assign({ type }, rest);
+        if (extensionData)
+            this.extensionData = flattenObject({ object: extensionData });
+        const numberOfExtensionDataProperties = Object.entries(this.extensionData).length;
+        if (numberOfExtensionDataProperties > MAX_EXT_ATTRIBUTES)
+            throw new Error(ERROR_MESSAGES.IV_006(MAX_EXT_ATTRIBUTES));
+        if (numberOfExtensionDataProperties > 0)
+            this.customEventPayload.ext = this.extensionData;
+        if (searchData)
+            this.customEventPayload.sc_search = {
+                data: searchData,
+                metadata: {
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    ut_api_version: '1.0',
+                },
+            };
+    }
+    /**
+     * Sends the event to Sitecore Edge Proxy
+     * @returns - A promise that resolves with either the Sitecore Edge Proxy response object or null
+     */
+    async send() {
+        const baseAttr = this.mapBaseEventPayload();
+        const fetchBody = Object.assign({}, this.customEventPayload, baseAttr);
+        return await this.sendEvent(fetchBody, this.config);
+    }
+}

package/dist/esm/src/events/custom-event/event.js

@@ -0,0 +1,24 @@
+import { getAnalyticsPlugin } from '@sitecore-content-sdk/analytics-core/internal';
+import { sendEvent } from '../send-event/sendEvent';
+import { CustomEvent } from './custom-event';
+import { getCoreContext } from '@sitecore-content-sdk/core';
+import { getEventsPlugin } from '../../initialization/plugin';
+/**
+ * A function that sends an event to the SitecoreCloud API with the specified type
+ * @param {EventData} eventData - The required/optional attributes to be sent to the SitecoreCloud API
+ * @returns The response object that Sitecore Edge Proxy returns
+ * @public
+ */
+export async function event(eventData) {
+    const coreContext = getCoreContext();
+    await coreContext.readyPromise;
+    getEventsPlugin();
+    const { options, adapter } = getAnalyticsPlugin();
+    const id = adapter.getClientId() || '';
+    return new CustomEvent({
+        eventData,
+        id,
+        sendEvent,
+        config: Object.assign(Object.assign({}, coreContext.config), options),
+    }).send();
+}

package/dist/esm/src/events/custom-event/form.js

@@ -0,0 +1,35 @@
+import { getAnalyticsPlugin } from '@sitecore-content-sdk/analytics-core/internal';
+import { sendEvent } from '../send-event/sendEvent';
+import { CustomEvent } from './custom-event';
+import { getCoreContext } from '@sitecore-content-sdk/core';
+import { getEventsPlugin } from '../../initialization/plugin';
+/**
+ * A function that sends a form event to the SitecoreCloud API
+ * @param {string} formId - The required form ID string
+ * @param {'VIEWED' | 'SUBMITTED'} interactionType - The required interaction type string. Possible values: `VIEWED`, `SUBMITTED`
+ * @param {string} componentInstanceId - The required component instance ID string
+ * @returns The response object that Sitecore Edge Proxy returns or null
+ * @public
+ */
+export async function form(formId, interactionType, componentInstanceId) {
+    const coreContext = getCoreContext();
+    await coreContext.readyPromise;
+    getEventsPlugin();
+    const { options, adapter } = getAnalyticsPlugin();
+    const id = adapter.getClientId() || '';
+    const formEvent = new CustomEvent({
+        eventData: {
+            extensionData: {
+                componentInstanceId,
+                formId,
+                interactionType: interactionType.toUpperCase(),
+            },
+            type: 'FORM',
+        },
+        id,
+        sendEvent,
+        config: Object.assign(Object.assign({}, coreContext.config), options),
+    });
+    formEvent.page = undefined;
+    return formEvent.send();
+}

package/dist/esm/src/events/identity/identity-event.js

@@ -0,0 +1,89 @@
+import { flattenObject, isShortISODateString, isValidEmail, } from '@sitecore-content-sdk/analytics-core/utils';
+import { BaseEvent } from '../base-event';
+import { MAX_EXT_ATTRIBUTES } from '../consts';
+import { constants } from '@sitecore-content-sdk/core';
+const { ERROR_MESSAGES } = constants;
+/**
+ * A class that extends from {@link BaseEvent} and has all the required functionality to send an IDENTITY event
+ */
+export class IdentityEvent extends BaseEvent {
+    /**
+     * A class that extends from {@link BaseEvent} and has all the required functionality to send an IDENTITY event
+     * @param {IdentityEventArguments} args - Unified object containing the required properties
+     */
+    constructor(args) {
+        const { channel, currency, language, page, extensionData } = args.identityData;
+        super({ channel, currency, language, page }, args.id);
+        this.extensionData = {};
+        this.numberOfExtensionDataProperties = 0;
+        this.validateAttributes(args.identityData);
+        this.identityData = args.identityData;
+        this.sendEvent = args.sendEvent;
+        this.config = args.config;
+        if (extensionData)
+            this.extensionData = flattenObject({ object: extensionData });
+        this.numberOfExtensionDataProperties = Object.entries(this.extensionData).length;
+        if (this.numberOfExtensionDataProperties > MAX_EXT_ATTRIBUTES)
+            throw new Error(ERROR_MESSAGES.IV_006(MAX_EXT_ATTRIBUTES));
+    }
+    /**
+     * Sends the event to Sitecore Edge Proxy
+     * @returns - A promise that resolves with either the Sitecore Edge Proxy response object or null
+     */
+    async send() {
+        const baseAttr = this.mapBaseEventPayload();
+        const eventAttrs = this.mapAttributes();
+        const fetchBody = Object.assign({}, eventAttrs, baseAttr);
+        return await this.sendEvent(fetchBody, this.config);
+    }
+    /**
+     * Function that validates the identifiers object, email, and date attributes for CDN users
+     * @param {IdentityData} identityData - The data to be validated
+     */
+    validateAttributes(identityData) {
+        if (identityData.identifiers.length === 0)
+            throw new Error(ERROR_MESSAGES.MV_003);
+        if (identityData.dob !== undefined && !isShortISODateString(identityData.dob))
+            throw new Error(ERROR_MESSAGES.IV_003);
+        identityData.identifiers.forEach((identifier) => {
+            if (identifier.expiryDate && !isShortISODateString(identifier.expiryDate))
+                throw new Error(ERROR_MESSAGES.IV_005);
+        });
+        if (identityData.email && !isValidEmail(identityData.email))
+            throw new Error(ERROR_MESSAGES.IV_004);
+    }
+    /**
+     * A function that maps the identity event input data with the payload sent to the API
+     * @returns - The payload object
+     */
+    mapAttributes() {
+        const identityPayload = {
+            city: this.identityData.city,
+            country: this.identityData.country,
+            dob: this.identityData.dob,
+            email: this.identityData.email,
+            firstname: this.identityData.firstName,
+            gender: this.identityData.gender,
+            identifiers: this.identityData.identifiers.map((value) => {
+                return {
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    expiry_date: value.expiryDate,
+                    id: value.id,
+                    provider: value.provider,
+                };
+            }),
+            lastname: this.identityData.lastName,
+            mobile: this.identityData.mobile,
+            phone: this.identityData.phone,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            postal_code: this.identityData.postalCode,
+            state: this.identityData.state,
+            street: this.identityData.street,
+            title: this.identityData.title,
+            type: 'IDENTITY',
+        };
+        if (this.numberOfExtensionDataProperties > 0)
+            identityPayload.ext = this.extensionData;
+        return identityPayload;
+    }
+}

package/dist/esm/src/events/identity/identity.js

@@ -0,0 +1,24 @@
+import { getAnalyticsPlugin } from '@sitecore-content-sdk/analytics-core/internal';
+import { sendEvent } from '../send-event/sendEvent';
+import { IdentityEvent } from './identity-event';
+import { getCoreContext } from '@sitecore-content-sdk/core';
+import { getEventsPlugin } from '../../initialization/plugin';
+/**
+ * A function that sends an IDENTITY event to the SitecoreCloud API
+ * @param {IdentityData} identityData - The required/optional attributes to be sent to the SitecoreCloud API
+ * @returns The response object that Sitecore Edge Proxy returns
+ * @public
+ */
+export async function identity(identityData) {
+    const coreContext = getCoreContext();
+    await coreContext.readyPromise;
+    getEventsPlugin();
+    const { options, adapter } = getAnalyticsPlugin();
+    const id = adapter.getClientId() || '';
+    return new IdentityEvent({
+        id,
+        identityData,
+        sendEvent,
+        config: Object.assign(Object.assign({}, coreContext.config), options),
+    }).send();
+}

package/dist/esm/src/events/index.js

@@ -0,0 +1,4 @@
+export { BaseEvent } from './base-event';
+export { PageViewEvent } from './page-view/page-view-event';
+export { CustomEvent } from './custom-event/custom-event';
+export { IdentityEvent } from './identity/identity-event';

package/dist/esm/src/events/page-view/page-view-event.js

@@ -0,0 +1,127 @@
+import { MAX_EXT_ATTRIBUTES, UTM_PREFIX } from '../consts';
+import { BaseEvent } from '../base-event';
+import { flattenObject } from '@sitecore-content-sdk/analytics-core/utils';
+import { constants } from '@sitecore-content-sdk/core';
+const { ERROR_MESSAGES } = constants;
+/**
+ * A class that extends from {@link BaseEvent} and has all the required functionality to send a VIEW event
+ */
+export class PageViewEvent extends BaseEvent {
+    /**
+     * A class that extends from {@link BaseEvent} and has all the required functionality to send a VIEW event
+     * @param {PageViewEventArguments} args - Unified object containing the required properties
+     */
+    constructor(args) {
+        var _a;
+        const { channel, currency, language, page, extensionData } = Object.assign({}, args.pageViewData);
+        super({
+            channel,
+            currency,
+            language,
+            page,
+        }, args.id);
+        this.extensionData = {};
+        this.pageViewData = args.pageViewData;
+        this.sendEvent = args.sendEvent;
+        this.config = args.config;
+        this.urlSearchParams = new URLSearchParams(decodeURI(args.searchParams));
+        if (extensionData)
+            this.extensionData = flattenObject({ object: extensionData });
+        const numberOfExtensionDataProperties = Object.entries(this.extensionData).length;
+        if (numberOfExtensionDataProperties > MAX_EXT_ATTRIBUTES)
+            throw new Error(ERROR_MESSAGES.IV_006(MAX_EXT_ATTRIBUTES));
+        this.includeUTMParameters =
+            (_a = (args.pageViewData && args.pageViewData.includeUTMParameters)) !== null && _a !== void 0 ? _a : true;
+    }
+    /**
+     * Sends the event to Sitecore Edge Proxy
+     * @returns - A promise that resolves with either the Sitecore Edge Proxy response object or null
+     */
+    async send() {
+        const baseAttr = this.mapBaseEventPayload();
+        const eventAttrs = this.mapAttributes();
+        PageViewEvent.isFirstPageView = false;
+        return await this.sendEvent(Object.assign(Object.assign({}, baseAttr), eventAttrs), this.config);
+    }
+    /**
+     * Gets the variant ID from the url if not passed by the developer
+     * Gets the variant ID from the extension data if not found from the url
+     * @param {string} [pageVariantIdFromPageViewData] - The variant ID from the page view data
+     * @param {string} [pageVariantIdFromExt] - The variant ID from extension data
+     * @returns - variant ID or null
+     */
+    getPageVariantId(pageVariantIdFromPageViewData, pageVariantIdFromExt) {
+        if (pageVariantIdFromPageViewData)
+            return pageVariantIdFromPageViewData;
+        const pageVariantIdFromURL = this.urlSearchParams.get('variantid');
+        if (pageVariantIdFromURL)
+            return pageVariantIdFromURL;
+        if (pageVariantIdFromExt)
+            return pageVariantIdFromExt;
+        return null;
+    }
+    /**
+     * Returns the referrer if exists on page view event else null if on server and no referrer is on event, else
+     * returns the href if on client side and the document referrer is different from the window location hostname
+     * @returns - the referrer
+     */
+    getReferrer() {
+        var _a;
+        if ((_a = this.pageViewData) === null || _a === void 0 ? void 0 : _a.referrer)
+            return this.pageViewData.referrer;
+        if (typeof window === 'undefined')
+            return null;
+        if (!PageViewEvent.isFirstPageView || !document.referrer)
+            return null;
+        const { hostname, href } = new URL(document.referrer);
+        return window.location.hostname !== hostname ? href : null;
+    }
+    /**
+     * Maps parameters given as input to corresponding attributes send to the API
+     * @returns the mapped object to be sent as payload
+     */
+    mapAttributes() {
+        var _a;
+        let pageViewPayload = {
+            type: 'VIEW',
+        };
+        const pageVariantId = this.pageViewData &&
+            this.getPageVariantId(this.pageViewData.pageVariantId, this.extensionData.pageVariantId);
+        if (pageVariantId !== null)
+            pageViewPayload.ext = Object.assign(Object.assign({}, pageViewPayload.ext), { pageVariantId });
+        if (Object.keys(this.extensionData).length > 0) {
+            delete this.extensionData.pageVariantId;
+            pageViewPayload.ext = Object.assign(Object.assign({}, pageViewPayload.ext), this.extensionData);
+        }
+        if (this.includeUTMParameters) {
+            const utmParameters = this.getUTMParameters();
+            pageViewPayload = Object.assign(Object.assign({}, pageViewPayload), utmParameters);
+        }
+        const referrer = this.getReferrer();
+        if (referrer !== null)
+            pageViewPayload = Object.assign(Object.assign({}, pageViewPayload), { referrer });
+        if ((_a = this.pageViewData) === null || _a === void 0 ? void 0 : _a.searchData)
+            pageViewPayload.sc_search = {
+                data: this.pageViewData.searchData,
+                metadata: {
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    ut_api_version: '1.0',
+                },
+            };
+        return pageViewPayload;
+    }
+    /**
+     * Retrieves UTM parameters from the url query string
+     * @returns - an object containing the UTM parameters if they exist
+     */
+    getUTMParameters() {
+        const utmParameters = {};
+        this.urlSearchParams.forEach((value, key) => {
+            const param = key.toLowerCase();
+            if (param.indexOf(UTM_PREFIX) === 0)
+                utmParameters[param] = value;
+        });
+        return utmParameters;
+    }
+}
+PageViewEvent.isFirstPageView = true;

package/dist/esm/src/events/page-view/page-view.js

@@ -0,0 +1,27 @@
+import { getAnalyticsPlugin } from '@sitecore-content-sdk/analytics-core/internal';
+import { sendEvent } from '../send-event/sendEvent';
+import { PageViewEvent } from './page-view-event';
+import { getCoreContext } from '@sitecore-content-sdk/core';
+import { getEventsPlugin } from '../../initialization/plugin';
+/**
+ * A function that sends a VIEW event to the SitecoreCloud API
+ * @param {PageViewData} [pageViewData] - The optional attributes to be sent to the SitecoreCloud API
+ * This object will be flattened and sent in the ext object of the payload
+ * @returns The response object that Sitecore Edge Proxy returns
+ * @public
+ */
+export async function pageView(pageViewData) {
+    const coreContext = getCoreContext();
+    await coreContext.readyPromise;
+    getEventsPlugin();
+    const { options, adapter } = getAnalyticsPlugin();
+    const id = adapter.getClientId() || '';
+    const searchParams = adapter.location.getSearchParams();
+    return new PageViewEvent({
+        id,
+        pageViewData,
+        searchParams,
+        sendEvent,
+        config: Object.assign(Object.assign({}, coreContext.config), options),
+    }).send();
+}

package/dist/esm/src/events/send-event/sendEvent.js

@@ -0,0 +1,33 @@
+import { API_VERSION } from '@sitecore-content-sdk/analytics-core/internal';
+import { PACKAGE_VERSION, X_CLIENT_SOFTWARE_ID } from '../../consts';
+import { NativeDataFetcher } from '@sitecore-content-sdk/core';
+import { debug } from '../../debug';
+/**
+ * This function sends an event to Sitecore Edge Proxy
+ * @param {EPFetchBody & BasePayload} body - The event data to send
+ * @param {CoreContext['config']} config - The global configuration
+ * @internal
+ */
+export async function sendEvent(body, config) {
+    // eslint-disable-next-line max-len
+    const eventUrl = `${config.edgeUrl}/v1/events/${API_VERSION}/events?siteId=${config.siteName}`;
+    const fetchOptions = {
+        body: JSON.stringify(body),
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Client-Software-ID': X_CLIENT_SOFTWARE_ID,
+            'X-Library-Version': PACKAGE_VERSION,
+            'x-sitecore-contextid': config.contextId,
+        },
+        method: 'POST',
+    };
+    const fetcher = new NativeDataFetcher({ debugger: debug.events });
+    return await fetcher
+        .fetch(eventUrl, fetchOptions)
+        .then(async (response) => {
+        return response.data;
+    })
+        .catch(() => {
+        return null;
+    });
+}

package/dist/esm/src/index.js

@@ -0,0 +1,5 @@
+export { form } from './events/custom-event/form';
+export { event } from './events/custom-event/event';
+export { identity } from './events/identity/identity';
+export { pageView } from './events/page-view/page-view';
+export { eventsPlugin } from './initialization/plugin';

package/dist/esm/src/initialization/const.js

@@ -0,0 +1,5 @@
+/**
+ * The name of the Events plugin.
+ * @public
+ */
+export const EVENTS_PLUGIN_NAME = 'EventsPlugin';

package/dist/esm/src/initialization/plugin.js

@@ -0,0 +1,52 @@
+import { getCoreContext, constants } from '@sitecore-content-sdk/core';
+import { EVENTS_PLUGIN_NAME } from './const';
+import { PACKAGE_VERSION } from '../consts';
+import { event } from '../events/custom-event/event';
+import { form } from '../events/custom-event/form';
+import { identity } from '../events/identity/identity';
+import { pageView } from '../events/page-view/page-view';
+import { addToEventQueue } from '../eventStorage/addToEventQueue';
+import { clearEventQueue } from '../eventStorage/clearEventQueue';
+import { processEventQueue } from '../eventStorage/processEventQueue';
+import { ANALYTICS_PLUGIN_NAME } from '@sitecore-content-sdk/analytics-core/internal';
+const { ERROR_MESSAGES } = constants;
+/**
+ * Initializes the events plugin with the provided options.
+ * @internal
+ */
+async function init() {
+    if (typeof window !== 'undefined')
+        window.scContentSDK = Object.assign(Object.assign({}, window.scContentSDK), { events: {
+                addToEventQueue,
+                clearEventQueue,
+                event,
+                form,
+                identity,
+                pageView,
+                processEventQueue,
+                version: PACKAGE_VERSION,
+            } });
+}
+/**
+ * Creates an events plugin with the provided options.
+ * @returns {EventsPlugin} The events plugin instance.
+ * @public
+ */
+export function eventsPlugin() {
+    return {
+        name: EVENTS_PLUGIN_NAME,
+        init,
+        dependencies: [ANALYTICS_PLUGIN_NAME],
+    };
+}
+/**
+ * Retrieves the events plugin instance from the core context.
+ * @returns {EventsPlugin} The events plugin instance.
+ * @internal
+ */
+export function getEventsPlugin() {
+    const plugin = getCoreContext().plugins.get(EVENTS_PLUGIN_NAME);
+    if (!plugin)
+        throw new Error(ERROR_MESSAGES.IE_004(EVENTS_PLUGIN_NAME));
+    return plugin;
+}

package/dist/esm/src/initialization/types.js

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

package/dist/esm/src/internal.js

@@ -0,0 +1,2 @@
+export { EVENTS_PLUGIN_NAME } from './initialization/const';
+export { PACKAGE_VERSION, PACKAGE_NAME } from './consts';

package/internal.d.ts

@@ -0,0 +1,2 @@
+export * from './types/src/internal';
+