@rebilly/instruments 4.4.0 → 4.6.0

package/src/events/base-event.js

@@ -1,47 +1,47 @@
 export class RegisteredListeners {
-  _listeners = {};
+    _listeners = {};
 
-  add(eventName, callback) {
-    document.addEventListener(eventName, callback, false);
+    add(eventName, callback) {
+        document.addEventListener(eventName, callback, false);
 
-    if (!(eventName in this._listeners)) {
-      this._listeners[eventName] = [];
+        if (!(eventName in this._listeners)) {
+            this._listeners[eventName] = [];
+        }
+        this._listeners[eventName].push(callback);
     }
-    this._listeners[eventName].push(callback);
-  }
 
-  removeAll() {
-    Object.keys(this._listeners).forEach((eventName) => {
-      this._listeners[eventName].forEach((callback) =>
-        document.removeEventListener(eventName, callback, false)
-      );
-    });
-    this._listeners = {};
-  }
+    removeAll() {
+        Object.keys(this._listeners).forEach((eventName) => {
+            this._listeners[eventName].forEach((callback) =>
+                document.removeEventListener(eventName, callback, false),
+            );
+        });
+        this._listeners = {};
+    }
 }
 
 export const registeredListeners = new RegisteredListeners();
 
 export default class BaseEvent {
-  /**
-   * @param {string} name
-   */
-  constructor(name) {
-    // Using namespaced internal name as a protection mechanism
-    const PREFIX = 'rebilly-instruments-';
-    this.internalName = PREFIX+ name;
-  }
+    /**
+     * @param {string} name
+     */
+    constructor(name) {
+        // Using namespaced internal name as a protection mechanism
+        const PREFIX = 'rebilly-instruments-';
+        this.internalName = PREFIX + name;
+    }
 
-  addEventListener(callback) {
-    const innerCallback = ({ detail }) => callback(detail);
-    registeredListeners.add(this.internalName, innerCallback);
-  }
+    addEventListener(callback) {
+        const innerCallback = ({ detail }) => callback(detail);
+        registeredListeners.add(this.internalName, innerCallback);
+    }
 
-  dispatch(detail) {
-    const event = new CustomEvent(this.internalName, {
-      bubbles: true,
-      detail
-    });
-    document.dispatchEvent(event);
-  }
+    dispatch(detail) {
+        const event = new CustomEvent(this.internalName, {
+            bubbles: true,
+            detail,
+        });
+        document.dispatchEvent(event);
+    }
 }

package/src/events/events.spec.js

@@ -2,10 +2,10 @@ import kebabCase from 'lodash.kebabcase';
 import events, { publicEventNames } from '@/events';
 
 it('Should export all public event names', async () => {
-  Object.keys(events).forEach((internalEventName) => {
-    expect(events[internalEventName].internalName).toEqual(
-      `rebilly-instruments-${kebabCase(internalEventName)}`
-    );
-    expect(kebabCase(internalEventName) in publicEventNames);
-  });
+    Object.keys(events).forEach((internalEventName) => {
+        expect(events[internalEventName].internalName).toEqual(
+            `rebilly-instruments-${kebabCase(internalEventName)}`,
+        );
+        expect(kebabCase(internalEventName) in publicEventNames);
+    });
 });

package/src/events/index.js

@@ -2,14 +2,14 @@ import kebabCase from 'lodash.kebabcase';
 import BaseEvent from './base-event';
 
 const events = {
-  dataReady: new BaseEvent('data-ready'),
-  instrumentReady: new BaseEvent('instrument-ready'),
-  purchaseCompleted: new BaseEvent('purchase-completed'),
-  setupCompleted: new BaseEvent('setup-completed')
+    dataReady: new BaseEvent('data-ready'),
+    instrumentReady: new BaseEvent('instrument-ready'),
+    purchaseCompleted: new BaseEvent('purchase-completed'),
+    setupCompleted: new BaseEvent('setup-completed'),
 };
 
 export default events;
 
 export const publicEventNames = Object.keys(events).map((internalName) =>
-  kebabCase(internalName)
+    kebabCase(internalName),
 );

package/src/functions/destroy.js

@@ -5,25 +5,25 @@ import state from '../state';
 import iframes from '../state/iframes';
 
 export async function destroy() {
-  // wait to allow for cancellation to catch any pending api requests
-  const sleepMilliseconds = 1000;
-  await sleep(sleepMilliseconds);
-  
-  Object.keys(iframes).forEach(frame => {
-    if (iframes.hasFrame(frame)) {
-      iframes[frame].destroy();
-      iframes[frame] = null;
-    }
-  });
+    // wait to allow for cancellation to catch any pending api requests
+    const sleepMilliseconds = 1000;
+    await sleep(sleepMilliseconds);
+
+    Object.keys(iframes).forEach((frame) => {
+        if (iframes.hasFrame(frame)) {
+            iframes[frame].destroy();
+            iframes[frame] = null;
+        }
+    });
 
-  registeredListeners.removeAll(document);
-  
-  state.hasMounted = false;
+    registeredListeners.removeAll(document);
 
-  if (state.summary) {
-    state.summary.textContent = '';
-  }
-  state.form.textContent = '';
-  cancellation.cancelAll();
-  state.loader.clearAll();
+    state.hasMounted = false;
+
+    if (state.summary) {
+        state.summary.textContent = '';
+    }
+    state.form.textContent = '';
+    cancellation.cancelAll();
+    state.loader.clearAll();
 }

package/src/functions/destroy.spec.js

@@ -3,61 +3,61 @@ import BaseEvent from '@/events/base-event';
 import { RenderMockRebillyInstruments } from 'tests/mocks/rebilly-instruments-mock';
 
 describe('RebillyInstruments Destroy', () => {
-  it('should be able to destroy instance', async () => {
-    const rebillyInstruments = await RenderMockRebillyInstruments();
+    it('should be able to destroy instance', async () => {
+        const rebillyInstruments = await RenderMockRebillyInstruments();
 
-    const formElement = document.querySelector('.form-selector');
-    const summaryElement = document.querySelector('.summary-selector');
+        const formElement = document.querySelector('.form-selector');
+        const summaryElement = document.querySelector('.summary-selector');
 
-    expect(formElement.innerHTML).not.toEqual('');
-    expect(summaryElement.innerHTML).not.toEqual('');
+        expect(formElement.innerHTML).not.toEqual('');
+        expect(summaryElement.innerHTML).not.toEqual('');
 
-    await rebillyInstruments.destroy();
+        await rebillyInstruments.destroy();
 
-    expect(formElement.innerHTML).toEqual('');
-    expect(summaryElement.innerHTML).toEqual('');
-  });
+        expect(formElement.innerHTML).toEqual('');
+        expect(summaryElement.innerHTML).toEqual('');
+    });
 
-  it('should remove registered listeners', async () => {
-    const rebillyInstruments = await RenderMockRebillyInstruments();
+    it('should remove registered listeners', async () => {
+        const rebillyInstruments = await RenderMockRebillyInstruments();
 
-    const fakeEventListener = vi.fn();
-    Events.fakeEvent = new BaseEvent('fake-event');
-    publicEventNames.push('fake-event');
-    rebillyInstruments.on('fake-event', fakeEventListener);
+        const fakeEventListener = vi.fn();
+        Events.fakeEvent = new BaseEvent('fake-event');
+        publicEventNames.push('fake-event');
+        rebillyInstruments.on('fake-event', fakeEventListener);
 
-    Events.fakeEvent.dispatch();
+        Events.fakeEvent.dispatch();
 
-    expect(fakeEventListener).toHaveBeenCalledTimes(1);
+        expect(fakeEventListener).toHaveBeenCalledTimes(1);
 
-    fakeEventListener.mockClear();
-    await rebillyInstruments.destroy();
+        fakeEventListener.mockClear();
+        await rebillyInstruments.destroy();
 
-    Events.fakeEvent.dispatch();
-    expect(fakeEventListener).not.toHaveBeenCalled();
-  });
+        Events.fakeEvent.dispatch();
+        expect(fakeEventListener).not.toHaveBeenCalled();
+    });
 
-  it('should remove multiple listeners on the same event', async () => {
-    const rebillyInstruments = await RenderMockRebillyInstruments();
+    it('should remove multiple listeners on the same event', async () => {
+        const rebillyInstruments = await RenderMockRebillyInstruments();
 
-    const fakeEventListener = vi.fn();
-    const anotherFakeEventListener = vi.fn();
-    Events.fakeEvent = new BaseEvent('fake-event');
-    publicEventNames.push('fake-event');
-    rebillyInstruments.on('fake-event', fakeEventListener);
-    rebillyInstruments.on('fake-event', anotherFakeEventListener);
+        const fakeEventListener = vi.fn();
+        const anotherFakeEventListener = vi.fn();
+        Events.fakeEvent = new BaseEvent('fake-event');
+        publicEventNames.push('fake-event');
+        rebillyInstruments.on('fake-event', fakeEventListener);
+        rebillyInstruments.on('fake-event', anotherFakeEventListener);
 
-    Events.fakeEvent.dispatch();
+        Events.fakeEvent.dispatch();
 
-    expect(fakeEventListener).toHaveBeenCalledTimes(1);
-    expect(anotherFakeEventListener).toHaveBeenCalledTimes(1);
+        expect(fakeEventListener).toHaveBeenCalledTimes(1);
+        expect(anotherFakeEventListener).toHaveBeenCalledTimes(1);
 
-    fakeEventListener.mockClear();
-    anotherFakeEventListener.mockClear();
-    await rebillyInstruments.destroy();
+        fakeEventListener.mockClear();
+        anotherFakeEventListener.mockClear();
+        await rebillyInstruments.destroy();
 
-    Events.fakeEvent.dispatch();
-    expect(fakeEventListener).not.toHaveBeenCalled();
-    expect(anotherFakeEventListener).not.toHaveBeenCalled();
-  });
+        Events.fakeEvent.dispatch();
+        expect(fakeEventListener).not.toHaveBeenCalled();
+        expect(anotherFakeEventListener).not.toHaveBeenCalled();
+    });
 });