@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/ejs/builders/events-node.js

@@ -0,0 +1,84 @@
+import { omit, pulseMerge } from '@schibsted/pulse-utils';
+import actorBuilder, { defaultValue as actorDefaultValue } from './actor';
+import consentsBuilder from './consents';
+import deviceBuilder, { defaultValue as deviceDefaultValue } from './device';
+import experimentMetadataBuilder, { defaultValue as experimentMetadataDefaultValue } from './experimentMetadata';
+import experimentsBuilder, { defaultValue as experimentsDefaultValue } from './experiments';
+import locationBuilder, { defaultValue as locationDefaultValue } from './location';
+import objectBuilder, { defaultValue as objectDefaultValue } from './objects/objects';
+import originBuilder, { defaultValue as originDefaultValue } from './origin';
+import providerBuilder, { defaultValue as providerDefaultValue } from './provider';
+import trackerBuilder, { defaultValue as trackerDefaultValue } from './trackerBuilder';
+export const DEFAULT_SCHEMA_LOCATION = 'schema.schibsted.com';
+function routableEventDefaults(eventInput) {
+    return pulseMerge({
+        actor: actorDefaultValue(),
+        provider: providerDefaultValue(),
+    }, eventInput);
+}
+/**
+ * Implements https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/events/base-routable-event.json
+ */
+export function routableEvent({ eventInput, sdkConfig } = {}) {
+    return Object.assign({}, eventInput, {
+        schema: eventInput?.schema ||
+            `http://${sdkConfig?.schemaLocation || DEFAULT_SCHEMA_LOCATION}/events/base-routable-event.json/246.json#`,
+        provider: providerBuilder(eventInput),
+        actor: actorBuilder(eventInput),
+    });
+}
+routableEvent.defaults = routableEventDefaults;
+/**
+ * Add default value to TrackerEventInput.
+ */
+function trackerEventInput(eventInput) {
+    return pulseMerge({
+        actor: actorDefaultValue(),
+        experiments: experimentsDefaultValue(),
+        experimentMetadata: experimentMetadataDefaultValue(),
+        device: deviceDefaultValue(),
+        location: locationDefaultValue(),
+        object: objectDefaultValue(),
+        origin: originDefaultValue(),
+        provider: providerDefaultValue(),
+        tracker: trackerDefaultValue(),
+    }, eventInput);
+}
+/**
+ * Implements https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/events/tracker-event.json
+ */
+export function trackerEvent({ eventInput, sdkConfig } = {}) {
+    const parentInput = trackerEventInput(eventInput);
+    const pageViewIdInput = eventInput?.pageViewId;
+    const pageViewIdSdk = sdkConfig?.pageViewId;
+    return Object.assign({}, omit(eventInput, ['type']), {
+        '@type': eventInput?.type || 'View',
+        pageViewId: pageViewIdInput || pageViewIdSdk,
+        schema: eventInput?.schema ||
+            `http://${sdkConfig?.schemaLocation || DEFAULT_SCHEMA_LOCATION}/events/tracker-event.json/359.json`,
+        actor: actorBuilder(parentInput),
+        consents: consentsBuilder(parentInput),
+        experiments: experimentsBuilder(parentInput),
+        experimentMetadata: experimentMetadataBuilder(parentInput),
+        device: deviceBuilder(parentInput),
+        location: locationBuilder(parentInput),
+        object: objectBuilder(parentInput),
+        origin: originBuilder(parentInput),
+        provider: providerBuilder(parentInput),
+        target: parentInput.target && objectBuilder(Object.assign({}, parentInput, { object: parentInput.target })),
+        tracker: trackerBuilder(parentInput),
+    });
+}
+trackerEvent.defaults = trackerEventInput;
+export function engagementEvent({ eventInput, sdkConfig } = {}) {
+    return Object.assign(trackerEvent({ eventInput, sdkConfig }), {
+        schema: eventInput?.schema ||
+            `http://${sdkConfig?.schemaLocation || DEFAULT_SCHEMA_LOCATION}/events/engagement-event.json/386.json`,
+        '@type': 'Engagement',
+    });
+}
+engagementEvent.defaults = trackerEventInput;
+export function identityEvent({ eventInput = {} } = {}) {
+    return eventInput;
+}
+identityEvent.defaults = () => ({});

package/dist/ejs/builders/events.js

@@ -0,0 +1 @@
+export * from './events-node';

package/dist/ejs/builders/experimentMetadata.js

@@ -0,0 +1,21 @@
+import { isObjectEmpty } from '@schibsted/pulse-utils';
+/**
+ * Format experiment metadata
+ */
+export default function experimentMetadata(input) {
+    const { errors, assignmentId, requestTimestamp } = input?.experimentMetadata || {};
+    const formattedExperimentMetadata = {};
+    if (errors?.length) {
+        formattedExperimentMetadata.errors = errors;
+    }
+    if (assignmentId) {
+        formattedExperimentMetadata.assignmentId = assignmentId;
+    }
+    if (requestTimestamp) {
+        formattedExperimentMetadata.requestTimestamp = requestTimestamp;
+    }
+    return isObjectEmpty(formattedExperimentMetadata) ? undefined : formattedExperimentMetadata;
+}
+export function defaultValue() {
+    return undefined;
+}

package/dist/ejs/builders/experiments.js

@@ -0,0 +1,27 @@
+function generateExperimentSDRN(id, experimentationPlatform) {
+    return `sdrn:${experimentationPlatform}:experiment:${id}`;
+}
+/**
+ * Attempts to format a correct "@id" given the input.
+ * Allows for the "@id" property to be completely overridden by the dev's input
+ * @param experiment
+ */
+function formatExperiment(experiment) {
+    const { id, platform, ...rest } = experiment || {};
+    return {
+        '@id': generateExperimentSDRN(id, platform),
+        ...(platform && { platform }),
+        ...rest,
+    };
+}
+/**
+ * Experiments builder
+ * @param input A full Pulse Event, from where the "experiments" property is parsed.
+ */
+export default function experiments(input) {
+    const experimentList = input?.experiments || [];
+    if (experimentList.length > 0) {
+        return experimentList.map(formatExperiment);
+    }
+}
+export const defaultValue = () => undefined;

package/dist/ejs/builders/index.js

@@ -0,0 +1,12 @@
+export * as actor from './actor';
+export * as consents from './consents';
+export * as device from './device';
+export * as events from './events';
+export * as experimentMetadata from './experimentMetadata';
+export * as experiments from './experiments';
+export * as location from './location';
+export * as objects from './objects/objects';
+export * as origin from './origin';
+export * as provider from './provider';
+export { default as session } from './session';
+export * as tracker from './trackerBuilder';

package/dist/ejs/builders/location.js

@@ -0,0 +1,34 @@
+const LOCATION_TYPE = 'GeoCoordinates';
+function geoToFixed(pos) {
+    if (pos !== null && pos !== undefined && pos !== '' && !Number.isNaN(pos)) {
+        return (Math.round(Number(pos) * 1000) / 1000.0).toFixed(3);
+    }
+}
+/**
+ * Create a valid Location object according to schema. Will create the
+ * required '@type' field, and reduce `latitude` and `longitude` accuracy
+ * to 3 decimal places.
+ *
+ * "altitude" is dropped from the result.
+ *
+ * Other input will be merged with the object as is.
+ *
+ * @see https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/objects/GeoCoordinates.json
+ */
+export default function location(input) {
+    const { location: locationInput } = input || {};
+    const { latitude: lat, longitude: long, altitude: _, ...rest } = locationInput || {}; // "altitude" is dropped
+    const latitude = geoToFixed(lat);
+    const longitude = geoToFixed(long);
+    if (latitude || longitude) {
+        return {
+            '@type': LOCATION_TYPE,
+            ...rest,
+            latitude,
+            longitude,
+        };
+    }
+}
+export function defaultValue() {
+    return undefined;
+}

package/dist/ejs/builders/objects/objects-anonymous-browser.js

@@ -0,0 +1,14 @@
+import { isBrowser } from '@schibsted/pulse-utils';
+export * from './objects-anonymous-node';
+export { default } from './objects-anonymous-node';
+export const defaultValue = () => {
+    if (!isBrowser) {
+        return {};
+    }
+    const { location = { href: undefined } } = window;
+    return {
+        name: document.title,
+        url: location.href,
+        id: location.href,
+    };
+};

package/dist/ejs/builders/objects/objects-anonymous-node.js

@@ -0,0 +1,90 @@
+import { isObject, isPlainObject, pulseMerge } from '@schibsted/pulse-utils';
+import { generateObjectSDRN } from './utils';
+/**
+ * Format UIElement.
+ *
+ * This will transform the object to a valid UIElement.
+ * When building the id of the UIElement it will primarily
+ * try to use 'page.id' and 'page.type' (if available).
+ * If page is not available it will fall back to use
+ * 'target.id' and 'target.type' when calling sdrn().
+ * If neither page nor target is available it will
+ * use default type from the object.
+ *
+ * @private
+ * @param data object and provider is mandatory, rest is optional.
+ */
+function formatUIElement({ object, provider, page, target }) {
+    const { id, type, custom, 'spt:custom': _, ...rest } = object || {};
+    const { id: pageId, type: pageType } = page || {};
+    const { id: targetId, type: targetType } = target || {};
+    const { id: providerId } = provider || {};
+    const uiElementId = pageType || targetType
+        ? `${generateObjectSDRN(pageId || targetId, providerId, pageType || targetType) || ''}:element:${id}`
+        : generateObjectSDRN(id, providerId, type);
+    const baseObject = {
+        '@id': uiElementId,
+        '@type': type,
+    };
+    return pulseMerge({}, baseObject, rest);
+}
+function formatDefaultObject({ object, provider }) {
+    const { id, type = 'Content', custom, 'spt:custom': _, ...rest } = object || {};
+    const { id: providerId } = provider || {};
+    const objectId = generateObjectSDRN(id, providerId, type);
+    let baseObject = {};
+    if (objectId) {
+        baseObject = {
+            '@id': objectId,
+            '@type': type,
+        };
+    }
+    return pulseMerge({}, baseObject, rest);
+}
+function getObjectFormatter(type) {
+    return type === 'UIElement' ? formatUIElement : formatDefaultObject;
+}
+/**
+ * Format object.
+ *
+ * This function will recursively format itself and all nested object.
+ * The initialPage parameter is optional and will be used in the recursive
+ * nature to always pass in the root object page to each formatting.
+ *
+ * @private
+ * @param {object} input
+ * @param {object|undefined} pageInput Optional
+ */
+export const formatObject = (input, pageInput) => {
+    const { object: objectInput = {} } = input || {};
+    const { page: pageInObject } = objectInput;
+    const page = pageInput || pageInObject;
+    const evaluatedObjectInput = Object.keys(objectInput).reduce((accl, key) => {
+        const prop = objectInput[key];
+        if (Array.isArray(prop)) {
+            return {
+                // biome-ignore lint/performance/noAccumulatingSpread: -
+                ...accl,
+                [key]: prop.map((o) => {
+                    if (isPlainObject(o)) {
+                        return formatObject(Object.assign({}, input, { object: o }), page);
+                    }
+                    return o;
+                }),
+            };
+        }
+        if (isObject(prop)) {
+            return {
+                // biome-ignore lint/performance/noAccumulatingSpread: -
+                ...accl,
+                [key]: formatObject(Object.assign({}, input, { object: prop }), page),
+            };
+        }
+        // biome-ignore lint/performance/noAccumulatingSpread: -
+        return { ...accl, [key]: prop };
+    }, {});
+    const output = Object.assign({}, input, { page, object: evaluatedObjectInput });
+    return getObjectFormatter(objectInput.type)(output);
+};
+export default formatObject;
+export const defaultValue = () => undefined;

package/dist/ejs/builders/objects/objects-anonymous.js

@@ -0,0 +1,2 @@
+export * from './objects-anonymous-node';
+export { default } from './objects-anonymous-node';

package/dist/ejs/builders/objects/objects-browser.js

@@ -0,0 +1,14 @@
+import { isBrowser } from '@schibsted/pulse-utils';
+export * from './objects-node';
+export { default } from './objects-node';
+export const defaultValue = () => {
+    if (!isBrowser) {
+        return {};
+    }
+    const { location = { href: undefined } } = window;
+    return {
+        name: document.title,
+        url: location.href,
+        id: location.href,
+    };
+};

package/dist/ejs/builders/objects/objects-node.js

@@ -0,0 +1,121 @@
+import { isObject, isPlainObject, pulseMerge } from '@schibsted/pulse-utils';
+import { generateObjectSDRN } from './utils';
+/**
+ * Format UIElement.
+ *
+ * This will transform the object to a valid UIElement.
+ * When building the id of the UIElement it will primarily
+ * try to use 'page.id' and 'page.type' (if available).
+ * If page is not available it will fall back to use
+ * 'target.id' and 'target.type' when calling sdrn().
+ * If neither page nor target is available it will
+ * use default type from the object.
+ *
+ * @private
+ * @param data object and provider is mandatory, rest is optional.
+ */
+function formatUIElement({ object, provider, page, target }) {
+    const { id, type, custom, ...rest } = object || {};
+    const { id: pageId, type: pageType } = page || {};
+    const { id: targetId, type: targetType } = target || {};
+    const { id: providerId } = provider || {};
+    const uiElementId = pageType || targetType
+        ? `${generateObjectSDRN(pageId || targetId, providerId, pageType || targetType) || ''}:element:${id}`
+        : generateObjectSDRN(id, providerId, type);
+    const baseObject = {
+        '@id': uiElementId,
+        '@type': type,
+    };
+    if (custom) {
+        baseObject['spt:custom'] = custom;
+    }
+    return pulseMerge({}, baseObject, rest);
+}
+function formatDefaultObject({ object, provider }) {
+    const { id, type = 'Content', custom, ...rest } = object || {};
+    const { id: providerId } = provider || {};
+    const objectId = generateObjectSDRN(id, providerId, type);
+    let baseObject = {};
+    if (objectId) {
+        baseObject = {
+            '@id': objectId,
+            '@type': type,
+        };
+    }
+    if (custom) {
+        baseObject['spt:custom'] = custom;
+    }
+    return pulseMerge({}, baseObject, rest);
+}
+function formatAccount({ object }) {
+    const { id, realm = 'schibsted.com', type: _, custom, ...rest } = object || {}; // type is dropped
+    if (!id) {
+        return;
+    }
+    const baseObject = {
+        '@id': `sdrn:${realm}:user:${id}`,
+        '@type': 'Account',
+        accountId: id,
+    };
+    if (custom) {
+        baseObject['spt:custom'] = custom;
+    }
+    return pulseMerge({}, baseObject, rest);
+}
+const objectFormatterMapping = {
+    UIElement: formatUIElement,
+    Account: formatAccount,
+};
+function getObjectFormatter(type) {
+    return objectFormatterMapping[type] || formatDefaultObject;
+}
+/**
+ * Format object.
+ *
+ * This function will recursively format itself and all nested object.
+ * The initialPage parameter is optional and will be used in the recursive
+ * nature to always pass in the root object page to each formatting.
+ *
+ * @param input
+ * @param pageInput
+ * @private
+ */
+export const formatObject = (input, pageInput) => {
+    const { object: objectInput = {} } = input || {};
+    const { page: pageInObject } = objectInput;
+    const page = pageInput || pageInObject;
+    const evaluatedObjectInput = Object.keys(objectInput).reduce((accl, key) => {
+        const prop = objectInput[key];
+        if (Array.isArray(prop)) {
+            return {
+                // biome-ignore lint/performance/noAccumulatingSpread: -
+                ...accl,
+                [key]: prop.map((o) => {
+                    if (isPlainObject(o)) {
+                        return formatObject(Object.assign({}, input, { object: o }), page);
+                    }
+                    return o;
+                }),
+            };
+        }
+        if (isObject(prop)) {
+            return {
+                // biome-ignore lint/performance/noAccumulatingSpread: -
+                ...accl,
+                [key]: formatObject(Object.assign({}, input, { object: prop }), page),
+            };
+        }
+        // biome-ignore lint/performance/noAccumulatingSpread: -
+        return { ...accl, [key]: prop };
+    }, {});
+    const output = Object.assign({}, input, { page, object: evaluatedObjectInput });
+    return getObjectFormatter(objectInput.type)(output);
+};
+/**
+ * @internal
+ */
+export default formatObject;
+/**
+ * @internal
+ */
+export const defaultValue = () => undefined;

package/dist/ejs/builders/objects/objects.js

@@ -0,0 +1,2 @@
+export * from './objects-node';
+export { default } from './objects-node';

package/dist/ejs/builders/objects/utils.js

@@ -0,0 +1,20 @@
+import { isString } from '@schibsted/pulse-utils';
+const objectTypeContentMapping = {
+    classifiedad: 'classified',
+    notificationcontent: 'notification',
+    businesstransaction: 'transaction',
+    uielement: 'element',
+};
+const getObjectContentByType = (type = '') => objectTypeContentMapping[type.toLowerCase()] ?? type.toLowerCase();
+function idIsFormatted(id) {
+    return isString(id) && id?.startsWith('sdrn:');
+}
+export function generateObjectSDRN(id, providerId, type) {
+    if (idIsFormatted(id)) {
+        return id;
+    }
+    if ((isString(id) || Number.isFinite(id)) && isString(providerId) && isString(type)) {
+        const contentType = getObjectContentByType(type);
+        return `sdrn:${providerId}:${contentType}:${id}`;
+    }
+}

package/dist/ejs/builders/origin-browser.js

@@ -0,0 +1,6 @@
+import { isBrowser } from '@schibsted/pulse-utils';
+export * from './origin-node';
+export { default } from './origin-node';
+export const defaultValue = () => ({
+    url: isBrowser ? document.referrer : '',
+});

package/dist/ejs/builders/origin-node.js

@@ -0,0 +1,24 @@
+import { isString } from '@schibsted/pulse-utils';
+import { generateObjectSDRN } from './objects/utils';
+// https://schibsted.ghe.com/data-platform/event-formats/blob/master/schema/master/common-definitions.json
+const originIdRegex = /^unknown$|^sdrn:(.*)$/;
+function isOriginSDRN(originId) {
+    return isString(originId) && originIdRegex.test(originId);
+}
+export default function origin(input) {
+    const { origin: originInput, provider } = input || {};
+    const { id: originInputId, type: originInputType, ...rest } = originInput || {};
+    const { id: providerId } = provider || {};
+    // If the id of origin has already been formatted upstream, we don't want to do it again
+    // This can happen, since previously we allowed the id through without any formatting and
+    // brands had to do it on their end to get it correctly.
+    const formattedOriginId = isOriginSDRN(originInputId)
+        ? originInputId
+        : generateObjectSDRN(originInputId, providerId, originInputType);
+    const base = {
+        ...(formattedOriginId && { '@id': formattedOriginId }),
+        ...(originInputType && { '@type': originInputType }),
+    };
+    return Object.assign({}, base, rest);
+}
+export const defaultValue = () => undefined;

package/dist/ejs/builders/origin.js

@@ -0,0 +1,2 @@
+export * from './origin-node';
+export { default } from './origin-node';

package/dist/ejs/builders/provider.js

@@ -0,0 +1,18 @@
+const PROVIDER_ID_UNDEFINED = '--PROVIDER-ID-NOT-DEFINED--';
+const DEFAULT_PROVIDER_TYPE = 'Organization';
+export function generateProviderSDRN(providerId) {
+    if (providerId) {
+        return `sdrn:schibsted:client:${providerId}`;
+    }
+    return PROVIDER_ID_UNDEFINED;
+}
+export default function provider(input) {
+    const { provider: providerInput } = input || {};
+    const { id, type = DEFAULT_PROVIDER_TYPE, ...rest } = providerInput || {};
+    const base = {
+        '@type': type,
+        '@id': generateProviderSDRN(id),
+    };
+    return Object.assign({}, base, rest);
+}
+export const defaultValue = () => undefined;

package/dist/ejs/builders/session-browser.js

@@ -0,0 +1,90 @@
+import { cookieConfig, getRootDomain, isBrowser, readCookie, writeCookie } from '@schibsted/pulse-utils';
+import { v4 as uuid } from 'uuid';
+const { USE_LOCALSTORAGE } = cookieConfig;
+const SESSION_STORAGE_KEY = '_pulsesession';
+const generateSessionSDRN = (sessionId) => `sdrn:schibsted:session:${sessionId}`;
+// Return parsed json from cookie (or localStorage if enabled), or undefined.
+export const readAndParse = (storageKey) => {
+    try {
+        const storedSession = readCookie(storageKey);
+        if (storedSession) {
+            return JSON.parse(storedSession);
+        }
+    }
+    catch (_e) {
+        // If localStorage/cookie is not available, we treat it as if
+        // the value is undefined.
+        // If data is unparseable, we also ignore it.
+        return undefined;
+    }
+    return undefined;
+};
+// Read and parse session data from localStorage.
+// Any invalid or unreadable data is ignored.
+export const readSession = () => {
+    const storedSession = readAndParse(SESSION_STORAGE_KEY);
+    if (storedSession) {
+        const [id, startTimeMs, lastEventTimeMs] = storedSession;
+        const startTime = new Date(startTimeMs);
+        const lastEventTime = new Date(lastEventTimeMs);
+        if (id &&
+            startTime &&
+            lastEventTime &&
+            !Number.isNaN(startTime.getTime()) &&
+            !Number.isNaN(lastEventTime.getTime())) {
+            return { id, startTime, lastEventTime };
+        }
+    }
+    return undefined;
+};
+// Write session data to localStorage
+const writeSession = (session) => {
+    const { id, startTime, lastEventTime } = session;
+    try {
+        const sessionToStore = [id, startTime.getTime(), lastEventTime.getTime()];
+        const halfHourInDays = 1.0 / (24 * 2);
+        writeCookie(SESSION_STORAGE_KEY, JSON.stringify(sessionToStore), getRootDomain(), halfHourInDays);
+        // Delete old localStorage-based session if needed
+        if (!USE_LOCALSTORAGE && isBrowser && window.localStorage) {
+            // removeItem will do nothing to a non-existing item.
+            window.localStorage.removeItem(SESSION_STORAGE_KEY);
+        }
+    }
+    catch (_e) {
+        // If we can't write the session, we just move on in life
+    }
+};
+const createSession = (eventCreationDate) => {
+    const now = eventCreationDate ?? new Date();
+    return {
+        id: generateSessionSDRN(uuid()),
+        startTime: now,
+        lastEventTime: now,
+    };
+};
+const updateSession = (session, eventCreationDate) => {
+    const now = eventCreationDate ?? new Date();
+    const sessionMaxInterval = 30 * 60 * 1000; // 30 minutes in milliseconds
+    if (!session || session.lastEventTime.getTime() < now.getTime() - sessionMaxInterval) {
+        return createSession(now);
+    }
+    return { ...session, lastEventTime: now };
+};
+export const defaultValue = () => undefined;
+// Add session information to an event
+// {
+//   "session": {
+//     "id": "sdrn:schibsted:session:123e4567-e89b-12d3-a456-426655440000",
+//     "startTime": "2020-01-21T12:29:00.999Z"
+//   }
+// }
+export default function session(_input, eventCreationDate) {
+    const oldSession = readSession();
+    const newSession = updateSession(oldSession, eventCreationDate);
+    writeSession(newSession);
+    const { id, startTime } = newSession;
+    return {
+        '@id': id,
+        startTime: startTime.toISOString(),
+    };
+}

package/dist/ejs/builders/session-node.js

@@ -0,0 +1,4 @@
+export const defaultValue = () => undefined;
+export default function (input) {
+    return input ?? {};
+}

package/dist/ejs/builders/session.js

@@ -0,0 +1,2 @@
+export * from './session-browser';
+export { default } from './session-browser';

package/dist/ejs/builders/tracker-browser.js

@@ -0,0 +1,13 @@
+export * from './tracker-node';
+export { default } from './tracker-node';
+/*
+ * this use case has not surfaced in any implementation:
+ */
+// export const defaultValue = () => {
+//   const { timing } = (window.performance || {});
+//   return {
+//     performance: {
+//       browser: timing ? timing.toJSON() : undefined,
+//     },
+//   };
+// };

package/dist/ejs/builders/tracker-node.js

@@ -0,0 +1,14 @@
+import version from '../version.json';
+/**
+ * Format tracker objects
+ */
+export default function tracker(input) {
+    const { tracker: trackerInput } = input || {};
+    const base = {
+        name: 'Pulse Node.js SDK',
+        type: 'JS',
+        version: version.SDK_VERSION,
+    };
+    return Object.assign({}, base, trackerInput);
+}
+export const defaultValue = () => undefined;

package/dist/ejs/builders/trackerBuilder.js

@@ -0,0 +1,2 @@
+export * from './tracker-node';
+export { default } from './tracker-node';