@jetshop/core 5.13.12-0 → 5.14.0

package/analytics/trackerRegistry.test.js

@@ -1,160 +1,160 @@
-import { trackerRegistry } from './trackerRegistry';
-
-test('Basic tracker gets their methods called', () => {
-  const fns = {
-    initBrowser: jest.fn(),
-    trackProduct: jest.fn(),
-    trackCartCheckout: jest.fn(),
-    trackList: jest.fn(),
-    trackPageView: jest.fn()
-  };
-  const tracker = {
-    name: 'test',
-    ...fns
-  };
-
-  const registry = new trackerRegistry({
-    inServer: false,
-    config: { trackingAllowed: true }
-  });
-
-  registry.add(tracker);
-
-  expect(tracker.initBrowser).toHaveBeenCalledTimes(1);
-
-  jest.resetAllMocks();
-  registry.emit('trackProduct');
-  expect(tracker.trackProduct).toHaveBeenCalledTimes(1);
-
-  jest.resetAllMocks();
-  registry.emit('trackCartCheckout');
-  expect(tracker.trackCartCheckout).toHaveBeenCalledTimes(1);
-
-  jest.resetAllMocks();
-  registry.emit('trackPageView');
-  expect(tracker.trackPageView).toHaveBeenCalledTimes(1);
-
-  jest.resetAllMocks();
-  registry.emit('trackCartCheckout');
-  expect(tracker.trackCartCheckout).toHaveBeenCalledTimes(1);
-});
-
-test('Trackers still get called if one fails', () => {
-  const nonce = `${Math.random()}`;
-  const bad = {
-    name: 'bad',
-    initBrowser: jest.fn(() => {
-      throw new Error(nonce);
-    }),
-    trackProduct: jest.fn(() => {
-      throw new Error(nonce);
-    })
-  };
-  const good1 = {
-    name: 'good1',
-    initBrowser: jest.fn(),
-    trackProduct: jest.fn()
-  };
-  const good2 = {
-    name: 'good2',
-    initBrowser: jest.fn(),
-    trackProduct: jest.fn()
-  };
-
-  const consoleError = jest
-    .spyOn(console, 'error')
-    .mockImplementation(() => {});
-
-  const registry = new trackerRegistry({
-    inServer: false,
-    config: { trackingAllowed: true }
-  });
-  registry.add(good1);
-  registry.add(bad);
-  registry.add(good2);
-
-  expect(good1.initBrowser).toHaveBeenCalledTimes(1);
-  expect(bad.initBrowser).toHaveBeenCalledTimes(1);
-  expect(good2.initBrowser).toHaveBeenCalledTimes(1);
-
-  expect(consoleError).toHaveBeenCalledTimes(1);
-  expect(consoleError.mock.calls[0][1].err.message).toContain(nonce);
-
-  jest.clearAllMocks();
-
-  // trackProduct()
-  registry.emit('trackProduct');
-
-  expect(good1.trackProduct).toHaveBeenCalledTimes(1);
-  expect(bad.trackProduct).toHaveBeenCalledTimes(1);
-  expect(good2.trackProduct).toHaveBeenCalledTimes(1);
-
-  expect(consoleError).toHaveBeenCalledTimes(1);
-  expect(consoleError.mock.calls[0][1].err.message).toContain(nonce);
-
-  // cleanup
-  jest.restoreAllMocks();
-});
-
-test('Events firing', () => {
-  const registry = new trackerRegistry({});
-
-  const callback = jest.fn();
-  registry.on('test', callback, {});
-  registry.emit('test');
-
-  expect(callback).toHaveBeenCalledTimes(1);
-});
-
-test('Respects do not tracking settings', () => {
-  const registry = new trackerRegistry({
-    inServer: false,
-    config: { trackingAllowed: false }
-  });
-
-  const good = {
-    name: 'good',
-    initBrowser: jest.fn(),
-    trackProduct: jest.fn()
-  };
-
-  registry.add(good);
-
-  expect(good.initBrowser).toHaveBeenCalledTimes(0);
-});
-
-test('Custom events', () => {
-  const registry = new trackerRegistry({
-    inServer: false,
-    config: { trackingAllowed: true }
-  });
-
-  const EVENT_NAME = `CUSTOM_EVENT_${Math.random()}`;
-
-  const eventCallback = jest.fn(() => {
-    throw new Error('Boo');
-  });
-  const tracker = {
-    name: 'test',
-    initBrowser({ trackerRegistry }) {
-      trackerRegistry.on(EVENT_NAME, eventCallback, { name: 'test' });
-    }
-  };
-
-  const consoleError = jest
-    .spyOn(console, 'error')
-    .mockImplementation(() => {});
-
-  registry.add(tracker);
-
-  registry.emit(EVENT_NAME, 'arg1', 'arg2', 'arg3');
-  registry.emit(EVENT_NAME);
-
-  expect(eventCallback).toHaveBeenCalledTimes(2);
-  expect(eventCallback).toHaveBeenCalledWith('arg1', 'arg2', 'arg3');
-
-  expect(consoleError).toHaveBeenCalledTimes(2);
-  expect(consoleError.mock.calls[0][0]).toContain(`${EVENT_NAME}:test`);
-
-  jest.restoreAllMocks();
-});
+import { trackerRegistry } from './trackerRegistry';
+
+test('Basic tracker gets their methods called', () => {
+  const fns = {
+    initBrowser: jest.fn(),
+    trackProduct: jest.fn(),
+    trackCartCheckout: jest.fn(),
+    trackList: jest.fn(),
+    trackPageView: jest.fn()
+  };
+  const tracker = {
+    name: 'test',
+    ...fns
+  };
+
+  const registry = new trackerRegistry({
+    inServer: false,
+    config: { trackingAllowed: true }
+  });
+
+  registry.add(tracker);
+
+  expect(tracker.initBrowser).toHaveBeenCalledTimes(1);
+
+  jest.resetAllMocks();
+  registry.emit('trackProduct');
+  expect(tracker.trackProduct).toHaveBeenCalledTimes(1);
+
+  jest.resetAllMocks();
+  registry.emit('trackCartCheckout');
+  expect(tracker.trackCartCheckout).toHaveBeenCalledTimes(1);
+
+  jest.resetAllMocks();
+  registry.emit('trackPageView');
+  expect(tracker.trackPageView).toHaveBeenCalledTimes(1);
+
+  jest.resetAllMocks();
+  registry.emit('trackCartCheckout');
+  expect(tracker.trackCartCheckout).toHaveBeenCalledTimes(1);
+});
+
+test('Trackers still get called if one fails', () => {
+  const nonce = `${Math.random()}`;
+  const bad = {
+    name: 'bad',
+    initBrowser: jest.fn(() => {
+      throw new Error(nonce);
+    }),
+    trackProduct: jest.fn(() => {
+      throw new Error(nonce);
+    })
+  };
+  const good1 = {
+    name: 'good1',
+    initBrowser: jest.fn(),
+    trackProduct: jest.fn()
+  };
+  const good2 = {
+    name: 'good2',
+    initBrowser: jest.fn(),
+    trackProduct: jest.fn()
+  };
+
+  const consoleError = jest
+    .spyOn(console, 'error')
+    .mockImplementation(() => {});
+
+  const registry = new trackerRegistry({
+    inServer: false,
+    config: { trackingAllowed: true }
+  });
+  registry.add(good1);
+  registry.add(bad);
+  registry.add(good2);
+
+  expect(good1.initBrowser).toHaveBeenCalledTimes(1);
+  expect(bad.initBrowser).toHaveBeenCalledTimes(1);
+  expect(good2.initBrowser).toHaveBeenCalledTimes(1);
+
+  expect(consoleError).toHaveBeenCalledTimes(1);
+  expect(consoleError.mock.calls[0][1].err.message).toContain(nonce);
+
+  jest.clearAllMocks();
+
+  // trackProduct()
+  registry.emit('trackProduct');
+
+  expect(good1.trackProduct).toHaveBeenCalledTimes(1);
+  expect(bad.trackProduct).toHaveBeenCalledTimes(1);
+  expect(good2.trackProduct).toHaveBeenCalledTimes(1);
+
+  expect(consoleError).toHaveBeenCalledTimes(1);
+  expect(consoleError.mock.calls[0][1].err.message).toContain(nonce);
+
+  // cleanup
+  jest.restoreAllMocks();
+});
+
+test('Events firing', () => {
+  const registry = new trackerRegistry({});
+
+  const callback = jest.fn();
+  registry.on('test', callback, {});
+  registry.emit('test');
+
+  expect(callback).toHaveBeenCalledTimes(1);
+});
+
+test('Respects do not tracking settings', () => {
+  const registry = new trackerRegistry({
+    inServer: false,
+    config: { trackingAllowed: false }
+  });
+
+  const good = {
+    name: 'good',
+    initBrowser: jest.fn(),
+    trackProduct: jest.fn()
+  };
+
+  registry.add(good);
+
+  expect(good.initBrowser).toHaveBeenCalledTimes(0);
+});
+
+test('Custom events', () => {
+  const registry = new trackerRegistry({
+    inServer: false,
+    config: { trackingAllowed: true }
+  });
+
+  const EVENT_NAME = `CUSTOM_EVENT_${Math.random()}`;
+
+  const eventCallback = jest.fn(() => {
+    throw new Error('Boo');
+  });
+  const tracker = {
+    name: 'test',
+    initBrowser({ trackerRegistry }) {
+      trackerRegistry.on(EVENT_NAME, eventCallback, { name: 'test' });
+    }
+  };
+
+  const consoleError = jest
+    .spyOn(console, 'error')
+    .mockImplementation(() => {});
+
+  registry.add(tracker);
+
+  registry.emit(EVENT_NAME, 'arg1', 'arg2', 'arg3');
+  registry.emit(EVENT_NAME);
+
+  expect(eventCallback).toHaveBeenCalledTimes(2);
+  expect(eventCallback).toHaveBeenCalledWith('arg1', 'arg2', 'arg3');
+
+  expect(consoleError).toHaveBeenCalledTimes(2);
+  expect(consoleError.mock.calls[0][0]).toContain(`${EVENT_NAME}:test`);
+
+  jest.restoreAllMocks();
+});

package/analytics/tracking.d.ts

@@ -1,14 +1,14 @@
-import { TrackProductProps, TrackCartProps, TrackListProps, TrackPageProps, TrackUserProps, TrackExperimentProps, TrackAddToWishListProps } from './trackerRegistry';
-import { TrackingEvent } from './Analytics';
-export * from './trackerRegistry';
-export * from './deprecatedTracking';
-export declare const trackProductEvent: (args: TrackProductProps) => TrackingEvent;
-export declare const trackCartCheckoutEvent: (args: TrackCartProps) => TrackingEvent;
-export declare const trackCartEvent: (args: TrackCartProps) => TrackingEvent;
-export declare const trackListEvent: (args: TrackListProps) => TrackingEvent;
-export declare const trackPageEvent: (args: TrackPageProps) => TrackingEvent;
-export declare const trackUserEvent: (args: TrackUserProps) => TrackingEvent;
-export declare const trackLoginEvent: () => TrackingEvent;
-export declare const trackRegisterEvent: () => TrackingEvent;
-export declare const trackAddToWishListEvent: (args: TrackAddToWishListProps) => TrackingEvent;
-export declare const trackExperimentEvent: (args: TrackExperimentProps) => TrackingEvent;
+import { TrackProductProps, TrackCartProps, TrackListProps, TrackPageProps, TrackUserProps, TrackExperimentProps, TrackAddToWishListProps } from './trackerRegistry';
+import { TrackingEvent } from './Analytics';
+export * from './trackerRegistry';
+export * from './deprecatedTracking';
+export declare const trackProductEvent: (args: TrackProductProps) => TrackingEvent;
+export declare const trackCartCheckoutEvent: (args: TrackCartProps) => TrackingEvent;
+export declare const trackCartEvent: (args: TrackCartProps) => TrackingEvent;
+export declare const trackListEvent: (args: TrackListProps) => TrackingEvent;
+export declare const trackPageEvent: (args: TrackPageProps) => TrackingEvent;
+export declare const trackUserEvent: (args: TrackUserProps) => TrackingEvent;
+export declare const trackLoginEvent: () => TrackingEvent;
+export declare const trackRegisterEvent: () => TrackingEvent;
+export declare const trackAddToWishListEvent: (args: TrackAddToWishListProps) => TrackingEvent;
+export declare const trackExperimentEvent: (args: TrackExperimentProps) => TrackingEvent;

package/analytics/tracking.js

@@ -1,72 +1,72 @@
-import { v4 as uuidv4 } from 'uuid';
-export * from './trackerRegistry';
-export * from './deprecatedTracking';
-export const trackProductEvent = (args) => {
-    return {
-        name: 'trackProduct',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackCartCheckoutEvent = (args) => {
-    return {
-        name: 'trackCartCheckout',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackCartEvent = (args) => {
-    return {
-        name: 'trackCart',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackListEvent = (args) => {
-    return {
-        name: 'trackList',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackPageEvent = (args) => {
-    return {
-        name: 'trackPageView',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackUserEvent = (args) => {
-    return {
-        name: 'trackUser',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackLoginEvent = () => {
-    return {
-        name: 'trackLogin',
-        id: uuidv4()
-    };
-};
-export const trackRegisterEvent = () => {
-    return {
-        name: 'trackRegister',
-        id: uuidv4()
-    };
-};
-export const trackAddToWishListEvent = (args) => {
-    return {
-        name: 'trackAddToWishList',
-        payload: args,
-        id: uuidv4()
-    };
-};
-export const trackExperimentEvent = (args) => {
-    return {
-        name: 'trackExperiment',
-        payload: args,
-        id: uuidv4()
-    };
-};
+import { v4 as uuidv4 } from 'uuid';
+export * from './trackerRegistry';
+export * from './deprecatedTracking';
+export const trackProductEvent = (args) => {
+    return {
+        name: 'trackProduct',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackCartCheckoutEvent = (args) => {
+    return {
+        name: 'trackCartCheckout',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackCartEvent = (args) => {
+    return {
+        name: 'trackCart',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackListEvent = (args) => {
+    return {
+        name: 'trackList',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackPageEvent = (args) => {
+    return {
+        name: 'trackPageView',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackUserEvent = (args) => {
+    return {
+        name: 'trackUser',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackLoginEvent = () => {
+    return {
+        name: 'trackLogin',
+        id: uuidv4()
+    };
+};
+export const trackRegisterEvent = () => {
+    return {
+        name: 'trackRegister',
+        id: uuidv4()
+    };
+};
+export const trackAddToWishListEvent = (args) => {
+    return {
+        name: 'trackAddToWishList',
+        payload: args,
+        id: uuidv4()
+    };
+};
+export const trackExperimentEvent = (args) => {
+    return {
+        name: 'trackExperiment',
+        payload: args,
+        id: uuidv4()
+    };
+};
 //# sourceMappingURL=tracking.js.map

package/analytics/utils/breadcrumbsWithoutProduct.d.ts

@@ -1 +1 @@
-export declare function breadcrumbsWithoutProduct(breadcrumbs?: string[]): string;
+export declare function breadcrumbsWithoutProduct(breadcrumbs?: string[]): string;

package/analytics/utils/breadcrumbsWithoutProduct.js

@@ -1,9 +1,9 @@
-export function breadcrumbsWithoutProduct(breadcrumbs) {
-    if (breadcrumbs && breadcrumbs.length) {
-        return '/' + breadcrumbs.slice(0, -1).join('/');
-    }
-    else {
-        return '';
-    }
-}
+export function breadcrumbsWithoutProduct(breadcrumbs) {
+    if (breadcrumbs && breadcrumbs.length) {
+        return '/' + breadcrumbs.slice(0, -1).join('/');
+    }
+    else {
+        return '';
+    }
+}
 //# sourceMappingURL=breadcrumbsWithoutProduct.js.map

package/analytics/utils/script.d.ts

@@ -1,8 +1,8 @@
-declare type ScriptProps = {
-    src: string;
-    async?: boolean;
-    defer?: boolean;
-    afterLoad?: boolean;
-};
-export declare const injectScript: ({ src, async, defer, afterLoad, ...otherProps }: ScriptProps) => void;
-export {};
+declare type ScriptProps = {
+    src: string;
+    async?: boolean;
+    defer?: boolean;
+    afterLoad?: boolean;
+};
+export declare const injectScript: ({ src, async, defer, afterLoad, ...otherProps }: ScriptProps) => void;
+export {};

package/analytics/utils/script.js

@@ -1,40 +1,40 @@
-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;
-};
-let windowLoaded = false;
-if (typeof window !== 'undefined') {
-    window.addEventListener('load', () => {
-        windowLoaded = true;
-    });
-}
-export const injectScript = (_a) => {
-    var { src, async = true, defer = true, afterLoad = true } = _a, otherProps = __rest(_a, ["src", "async", "defer", "afterLoad"]);
-    const inject = () => {
-        // Create script element
-        const script = document.createElement('script');
-        script.type = 'text/javascript';
-        script.async = async;
-        script.defer = defer;
-        script.src = src;
-        Object.apply(script, otherProps);
-        // Insert element
-        document.head.appendChild(script);
-        // Clean up event listener
-        afterLoad && window.removeEventListener('load', inject);
-    };
-    if (afterLoad && !windowLoaded) {
-        window.addEventListener('load', inject);
-    }
-    else {
-        inject();
-    }
-};
+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;
+};
+let windowLoaded = false;
+if (typeof window !== 'undefined') {
+    window.addEventListener('load', () => {
+        windowLoaded = true;
+    });
+}
+export const injectScript = (_a) => {
+    var { src, async = true, defer = true, afterLoad = true } = _a, otherProps = __rest(_a, ["src", "async", "defer", "afterLoad"]);
+    const inject = () => {
+        // Create script element
+        const script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.async = async;
+        script.defer = defer;
+        script.src = src;
+        Object.apply(script, otherProps);
+        // Insert element
+        document.head.appendChild(script);
+        // Clean up event listener
+        afterLoad && window.removeEventListener('load', inject);
+    };
+    if (afterLoad && !windowLoaded) {
+        window.addEventListener('load', inject);
+    }
+    else {
+        inject();
+    }
+};
 //# sourceMappingURL=script.js.map

package/analytics/webVitals.d.ts

@@ -1,5 +1,5 @@
-export declare function setPageType(type: string): void;
-export declare function webVitals({ shopId, apiUrl }: {
-    shopId: string;
-    apiUrl: string;
-}): void;
+export declare function setPageType(type: string): void;
+export declare function webVitals({ shopId, apiUrl }: {
+    shopId: string;
+    apiUrl: string;
+}): void;