@jetshop/core 5.13.2 → 5.13.12-0

package/experiments/integration.test.js

@@ -1,76 +1,76 @@
-import React from 'react';
-import { render, cleanup } from '@testing-library/react';
-import useExperiment from './useExperiment';
-import { StaticRouter } from 'react-router';
-import { CookiesProvider } from 'react-cookie';
-import Cookies from 'universal-cookie';
-import ExperimentsProvider from './ExperimentsProvider';
-import AnalyticsProvider from '../analytics/AnalyticsProvider';
-import { ConfigProvider } from '../components/ConfigProvider';
-import { ChannelProvider } from '../components/ChannelContext';
-import { ChannelHandler } from '../ChannelHandler/ChannelHandler';
-import { channels, selectedChannel } from '../test-utils/variables';
-import { HelmetProvider } from 'react-helmet-async';
-afterEach(cleanup);
-
-const Experiment = () => {
-  const first = useExperiment('test', 1);
-  const second = useExperiment('test', 2);
-
-  if (first) {
-    return <div>First</div>;
-  } else if (second) {
-    return <div>Second</div>;
-  } else {
-    return <div>Original</div>;
-  }
-};
-
-const setup = ({ cookies }) => {
-  const channelHandler = new ChannelHandler({
-    channels,
-    selectedChannel,
-  });
-  return render(
-    <StaticRouter>
-      <CookiesProvider cookies={cookies}>
-        <HelmetProvider context={{}}>
-          <ChannelProvider channelHandler={channelHandler}>
-            <ConfigProvider config={{}}>
-              <AnalyticsProvider config={{}}>
-                <ExperimentsProvider>
-                  <Experiment />
-                </ExperimentsProvider>
-              </AnalyticsProvider>
-            </ConfigProvider>
-          </ChannelProvider>
-        </HelmetProvider>
-      </CookiesProvider>
-    </StaticRouter>
-  );
-};
-
-describe('experiments', () => {
-  describe('a/b testing', () => {
-    beforeEach(() => {
-      // Workaround changes in universal-cookie
-      Object.defineProperty(document, 'cookie', {
-        value: null,
-      });
-    });
-
-    it('renders original if no cookie was set', () => {
-      const cookies = new Cookies({});
-      const { getByText } = setup({ cookies });
-      expect(getByText('Original')).toBeTruthy();
-    });
-
-    it('renders a specific variant if that variant was selected', () => {
-      const cookies = new Cookies({
-        optimizeExperiment: 'test.2',
-      });
-      const { getByText } = setup({ cookies });
-      expect(getByText('Second')).toBeTruthy();
-    });
-  });
-});
+import React from 'react';
+import { render, cleanup } from '@testing-library/react';
+import useExperiment from './useExperiment';
+import { StaticRouter } from 'react-router';
+import { CookiesProvider } from 'react-cookie';
+import Cookies from 'universal-cookie';
+import ExperimentsProvider from './ExperimentsProvider';
+import AnalyticsProvider from '../analytics/AnalyticsProvider';
+import { ConfigProvider } from '../components/ConfigProvider';
+import { ChannelProvider } from '../components/ChannelContext';
+import { ChannelHandler } from '../ChannelHandler/ChannelHandler';
+import { channels, selectedChannel } from '../test-utils/variables';
+import { HelmetProvider } from 'react-helmet-async';
+afterEach(cleanup);
+
+const Experiment = () => {
+  const first = useExperiment('test', 1);
+  const second = useExperiment('test', 2);
+
+  if (first) {
+    return <div>First</div>;
+  } else if (second) {
+    return <div>Second</div>;
+  } else {
+    return <div>Original</div>;
+  }
+};
+
+const setup = ({ cookies }) => {
+  const channelHandler = new ChannelHandler({
+    channels,
+    selectedChannel,
+  });
+  return render(
+    <StaticRouter>
+      <CookiesProvider cookies={cookies}>
+        <HelmetProvider context={{}}>
+          <ChannelProvider channelHandler={channelHandler}>
+            <ConfigProvider config={{}}>
+              <AnalyticsProvider config={{}}>
+                <ExperimentsProvider>
+                  <Experiment />
+                </ExperimentsProvider>
+              </AnalyticsProvider>
+            </ConfigProvider>
+          </ChannelProvider>
+        </HelmetProvider>
+      </CookiesProvider>
+    </StaticRouter>
+  );
+};
+
+describe('experiments', () => {
+  describe('a/b testing', () => {
+    beforeEach(() => {
+      // Workaround changes in universal-cookie
+      Object.defineProperty(document, 'cookie', {
+        value: null,
+      });
+    });
+
+    it('renders original if no cookie was set', () => {
+      const cookies = new Cookies({});
+      const { getByText } = setup({ cookies });
+      expect(getByText('Original')).toBeTruthy();
+    });
+
+    it('renders a specific variant if that variant was selected', () => {
+      const cookies = new Cookies({
+        optimizeExperiment: 'test.2',
+      });
+      const { getByText } = setup({ cookies });
+      expect(getByText('Second')).toBeTruthy();
+    });
+  });
+});

package/experiments/selectExperimentVariant.d.ts

@@ -1,3 +1,3 @@
-import { OptimizeConfig } from '../components/ConfigProvider';
-declare function selectExperimentVariant(config: OptimizeConfig, selectedVariant: string): string;
-export default selectExperimentVariant;
+import { OptimizeConfig } from '../components/ConfigProvider';
+declare function selectExperimentVariant(config: OptimizeConfig, selectedVariant: string): string;
+export default selectExperimentVariant;

package/experiments/selectExperimentVariant.js

@@ -1,35 +1,35 @@
-function selectExperimentVariant(config, selectedVariant) {
-    // If no experiment is configured, do nothing.
-    if (!config) {
-        return null;
-    }
-    // A valid cookie has the format xxxxxxxx.n where the first part is the experiment id and the second part is the variant index
-    const parts = (selectedVariant || '').split('.');
-    if (parts.length === 2) {
-        const [experiment, variant] = parts;
-        // Make sure the cookie refers to the currently configured experiment
-        if (experiment === config.experimentId) {
-            // Make sure that the variant index is withing the amount of variants we have configured
-            if (parseInt(variant, 10) < config.variantWeights.length) {
-                return selectedVariant;
-            }
-        }
-    }
-    const totalWeights = config.variantWeights.reduce((sum, cur) => sum + cur, 0);
-    const absoluteWeights = config.variantWeights.map(weight => weight / totalWeights);
-    // We either have no previous cookie, or an invalid one, so let's select a variant and set up the cookie
-    const randomValue = Math.random();
-    const variantCount = absoluteWeights.length;
-    let i = 0, sum = 0;
-    for (; i < variantCount; i++) {
-        if (randomValue < sum + absoluteWeights[i]) {
-            break;
-        }
-        else {
-            sum += absoluteWeights[i];
-        }
-    }
-    return `${config.experimentId}.${i}`;
-}
-export default selectExperimentVariant;
+function selectExperimentVariant(config, selectedVariant) {
+    // If no experiment is configured, do nothing.
+    if (!config) {
+        return null;
+    }
+    // A valid cookie has the format xxxxxxxx.n where the first part is the experiment id and the second part is the variant index
+    const parts = (selectedVariant || '').split('.');
+    if (parts.length === 2) {
+        const [experiment, variant] = parts;
+        // Make sure the cookie refers to the currently configured experiment
+        if (experiment === config.experimentId) {
+            // Make sure that the variant index is withing the amount of variants we have configured
+            if (parseInt(variant, 10) < config.variantWeights.length) {
+                return selectedVariant;
+            }
+        }
+    }
+    const totalWeights = config.variantWeights.reduce((sum, cur) => sum + cur, 0);
+    const absoluteWeights = config.variantWeights.map(weight => weight / totalWeights);
+    // We either have no previous cookie, or an invalid one, so let's select a variant and set up the cookie
+    const randomValue = Math.random();
+    const variantCount = absoluteWeights.length;
+    let i = 0, sum = 0;
+    for (; i < variantCount; i++) {
+        if (randomValue < sum + absoluteWeights[i]) {
+            break;
+        }
+        else {
+            sum += absoluteWeights[i];
+        }
+    }
+    return `${config.experimentId}.${i}`;
+}
+export default selectExperimentVariant;
 //# sourceMappingURL=selectExperimentVariant.js.map

package/experiments/selectExperimentVariant.test.js

@@ -1,64 +1,64 @@
-import selectExperimentVariant from './selectExperimentVariant';
-
-describe('selectExperimentVariant', () => {
-  it('returns null if no config is supplied', () => {
-    expect(selectExperimentVariant(null)).toBe(null);
-  });
-
-  it('returns the previous value if experiment matches the config', () => {
-    const config = {
-      experimentId: 'test',
-      variantWeights: [0.5]
-    };
-
-    const selectedVariant = 'test.0';
-
-    expect(selectExperimentVariant(config, selectedVariant)).toBe(
-      selectedVariant
-    );
-  });
-
-  it('returns a new value if experiment id is correct but variant is out of range', () => {
-    const config = {
-      experimentId: 'test',
-      variantWeights: [1]
-    };
-
-    const selectedVariant = 'test.2';
-
-    const newVariant = selectExperimentVariant(config, selectedVariant);
-    expect(newVariant).not.toBe(selectedVariant);
-    expect(newVariant).toBe('test.0');
-  });
-
-  it('returns a new value if experiment id is wrong', () => {
-    const config = {
-      experimentId: 'other',
-      variantWeights: [1]
-    };
-
-    const selectedVariant = 'test.0';
-
-    const newVariant = selectExperimentVariant(config, selectedVariant);
-    expect(newVariant).not.toBe(selectedVariant);
-    expect(newVariant).toBe('other.0');
-  });
-
-  it('selects a random variant if no previous one was provided', () => {
-    const config = {
-      experimentId: 'test',
-      variantWeights: [0.25, 0.25, 0.25, 0.25]
-    };
-
-    expect(selectExperimentVariant(config, null)).not.toBe(null);
-  });
-
-  it('works if sum of variant weights is more than 1', () => {
-    const config = {
-      experimentId: 'test',
-      variantWeights: [1, 1, 1, 1]
-    };
-
-    expect(selectExperimentVariant(config, null)).not.toBe(null);
-  });
-});
+import selectExperimentVariant from './selectExperimentVariant';
+
+describe('selectExperimentVariant', () => {
+  it('returns null if no config is supplied', () => {
+    expect(selectExperimentVariant(null)).toBe(null);
+  });
+
+  it('returns the previous value if experiment matches the config', () => {
+    const config = {
+      experimentId: 'test',
+      variantWeights: [0.5]
+    };
+
+    const selectedVariant = 'test.0';
+
+    expect(selectExperimentVariant(config, selectedVariant)).toBe(
+      selectedVariant
+    );
+  });
+
+  it('returns a new value if experiment id is correct but variant is out of range', () => {
+    const config = {
+      experimentId: 'test',
+      variantWeights: [1]
+    };
+
+    const selectedVariant = 'test.2';
+
+    const newVariant = selectExperimentVariant(config, selectedVariant);
+    expect(newVariant).not.toBe(selectedVariant);
+    expect(newVariant).toBe('test.0');
+  });
+
+  it('returns a new value if experiment id is wrong', () => {
+    const config = {
+      experimentId: 'other',
+      variantWeights: [1]
+    };
+
+    const selectedVariant = 'test.0';
+
+    const newVariant = selectExperimentVariant(config, selectedVariant);
+    expect(newVariant).not.toBe(selectedVariant);
+    expect(newVariant).toBe('other.0');
+  });
+
+  it('selects a random variant if no previous one was provided', () => {
+    const config = {
+      experimentId: 'test',
+      variantWeights: [0.25, 0.25, 0.25, 0.25]
+    };
+
+    expect(selectExperimentVariant(config, null)).not.toBe(null);
+  });
+
+  it('works if sum of variant weights is more than 1', () => {
+    const config = {
+      experimentId: 'test',
+      variantWeights: [1, 1, 1, 1]
+    };
+
+    expect(selectExperimentVariant(config, null)).not.toBe(null);
+  });
+});

package/experiments/useExperiment.d.ts

@@ -1,2 +1,2 @@
-declare const useExperiment: (experimentId: string, variantIndex: number) => boolean;
-export default useExperiment;
+declare const useExperiment: (experimentId: string, variantIndex: number) => boolean;
+export default useExperiment;

package/experiments/useExperiment.js

@@ -1,11 +1,11 @@
-import { useContext } from 'react';
-import { ExperimentsContext } from './ExperimentsProvider';
-const useExperiment = (experimentId, variantIndex) => {
-    const { experiment, variant } = useContext(ExperimentsContext);
-    return (experiment !== null &&
-        variant !== null &&
-        experiment === experimentId &&
-        variant === variantIndex);
-};
-export default useExperiment;
+import { useContext } from 'react';
+import { ExperimentsContext } from './ExperimentsProvider';
+const useExperiment = (experimentId, variantIndex) => {
+    const { experiment, variant } = useContext(ExperimentsContext);
+    return (experiment !== null &&
+        variant !== null &&
+        experiment === experimentId &&
+        variant === variantIndex);
+};
+export default useExperiment;
 //# sourceMappingURL=useExperiment.js.map

package/experiments/useExperiment.test.js

@@ -1,100 +1,100 @@
-import React from 'react';
-import { render, cleanup } from '@testing-library/react';
-import useExperiment from './useExperiment';
-import { StaticRouter } from 'react-router';
-import { CookiesProvider } from 'react-cookie';
-import Cookies from 'universal-cookie';
-import ExperimentsProvider from './ExperimentsProvider';
-import AnalyticsProvider from '../analytics/AnalyticsProvider';
-import { ConfigProvider } from '../components/ConfigProvider';
-import { ChannelProvider } from '../components/ChannelContext';
-import { ChannelHandler } from '../ChannelHandler/ChannelHandler';
-import { selectedChannel, channels } from '../test-utils/variables';
-import { HelmetProvider } from 'react-helmet-async';
-afterEach(cleanup);
-
-const Collector = ({ report, id, variant }) => {
-  const data = useExperiment(id, variant);
-  report(data);
-  return null;
-};
-
-const setup = ({ report, id, variant, cookies }) => {
-  const channelHandler = new ChannelHandler({
-    selectedChannel,
-    channels,
-  });
-  return render(
-    <StaticRouter>
-      <CookiesProvider cookies={cookies}>
-        <HelmetProvider context={{}}>
-          <ChannelProvider channelHandler={channelHandler}>
-            <ConfigProvider config={{}}>
-              <AnalyticsProvider config={{}}>
-                <ExperimentsProvider>
-                  <Collector report={report} id={id} variant={variant} />
-                </ExperimentsProvider>
-              </AnalyticsProvider>
-            </ConfigProvider>
-          </ChannelProvider>
-        </HelmetProvider>
-      </CookiesProvider>
-    </StaticRouter>
-  );
-};
-
-describe('useExperiment', () => {
-  beforeEach(() => {
-    // Workaround changes in universal-cookie
-    Object.defineProperty(document, 'cookie', {
-      value: null,
-    });
-  });
-
-  it('returns false if no cookie is set', () => {
-    const cookies = new Cookies({});
-
-    const report = jest.fn();
-    setup({
-      cookies,
-      report,
-      id: null,
-      variant: null,
-    });
-
-    expect(report).toHaveBeenCalledTimes(1);
-    expect(report).toHaveBeenCalledWith(false);
-  });
-
-  it('returns false if cookie does not match provided experiment and variant', () => {
-    const cookies = new Cookies({
-      optimizeExperiment: 'test.0',
-    });
-    const report = jest.fn();
-    setup({
-      cookies,
-      report,
-      id: 'test',
-      variant: 1,
-    });
-
-    expect(report).toHaveBeenCalledTimes(1);
-    expect(report).toHaveBeenCalledWith(false);
-  });
-
-  it('returns true if cookie matches provided experiment and variant', () => {
-    const cookies = new Cookies({
-      optimizeExperiment: 'test.0',
-    });
-    const report = jest.fn();
-    setup({
-      cookies,
-      report,
-      id: 'test',
-      variant: 0,
-    });
-
-    expect(report).toHaveBeenCalledTimes(1);
-    expect(report).toHaveBeenCalledWith(true);
-  });
-});
+import React from 'react';
+import { render, cleanup } from '@testing-library/react';
+import useExperiment from './useExperiment';
+import { StaticRouter } from 'react-router';
+import { CookiesProvider } from 'react-cookie';
+import Cookies from 'universal-cookie';
+import ExperimentsProvider from './ExperimentsProvider';
+import AnalyticsProvider from '../analytics/AnalyticsProvider';
+import { ConfigProvider } from '../components/ConfigProvider';
+import { ChannelProvider } from '../components/ChannelContext';
+import { ChannelHandler } from '../ChannelHandler/ChannelHandler';
+import { selectedChannel, channels } from '../test-utils/variables';
+import { HelmetProvider } from 'react-helmet-async';
+afterEach(cleanup);
+
+const Collector = ({ report, id, variant }) => {
+  const data = useExperiment(id, variant);
+  report(data);
+  return null;
+};
+
+const setup = ({ report, id, variant, cookies }) => {
+  const channelHandler = new ChannelHandler({
+    selectedChannel,
+    channels,
+  });
+  return render(
+    <StaticRouter>
+      <CookiesProvider cookies={cookies}>
+        <HelmetProvider context={{}}>
+          <ChannelProvider channelHandler={channelHandler}>
+            <ConfigProvider config={{}}>
+              <AnalyticsProvider config={{}}>
+                <ExperimentsProvider>
+                  <Collector report={report} id={id} variant={variant} />
+                </ExperimentsProvider>
+              </AnalyticsProvider>
+            </ConfigProvider>
+          </ChannelProvider>
+        </HelmetProvider>
+      </CookiesProvider>
+    </StaticRouter>
+  );
+};
+
+describe('useExperiment', () => {
+  beforeEach(() => {
+    // Workaround changes in universal-cookie
+    Object.defineProperty(document, 'cookie', {
+      value: null,
+    });
+  });
+
+  it('returns false if no cookie is set', () => {
+    const cookies = new Cookies({});
+
+    const report = jest.fn();
+    setup({
+      cookies,
+      report,
+      id: null,
+      variant: null,
+    });
+
+    expect(report).toHaveBeenCalledTimes(1);
+    expect(report).toHaveBeenCalledWith(false);
+  });
+
+  it('returns false if cookie does not match provided experiment and variant', () => {
+    const cookies = new Cookies({
+      optimizeExperiment: 'test.0',
+    });
+    const report = jest.fn();
+    setup({
+      cookies,
+      report,
+      id: 'test',
+      variant: 1,
+    });
+
+    expect(report).toHaveBeenCalledTimes(1);
+    expect(report).toHaveBeenCalledWith(false);
+  });
+
+  it('returns true if cookie matches provided experiment and variant', () => {
+    const cookies = new Cookies({
+      optimizeExperiment: 'test.0',
+    });
+    const report = jest.fn();
+    setup({
+      cookies,
+      report,
+      id: 'test',
+      variant: 0,
+    });
+
+    expect(report).toHaveBeenCalledTimes(1);
+    expect(report).toHaveBeenCalledWith(true);
+  });
+});

package/global.d.ts

@@ -1 +1 @@
-declare var __IN_SERVER__: boolean;
+declare var __IN_SERVER__: boolean;

package/helpers/decodeUrlQuery.d.ts

@@ -1,9 +1,9 @@
-declare const decodeUrlQuery: ({ urlQuery, parametersToBeDecoded }: {
-    urlQuery: {
-        [key: string]: string;
-    };
-    parametersToBeDecoded?: string[];
-}) => {
-    [x: string]: string;
-};
-export default decodeUrlQuery;
+declare const decodeUrlQuery: ({ urlQuery, parametersToBeDecoded }: {
+    urlQuery: {
+        [key: string]: string;
+    };
+    parametersToBeDecoded?: string[];
+}) => {
+    [x: string]: string;
+};
+export default decodeUrlQuery;