@notabene/javascript-sdk 1.32.0 → 2.0.0-next.10

package/src/components/__tests__/EmbeddedComponent.test.ts

@@ -0,0 +1,160 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { CMType, HMType, HostMessage, Transaction } from '../../types';
+import EmbeddedComponent from '../EmbeddedComponent';
+
+const url = 'https://example.com';
+const parentId = 'parent-container';
+const value: Partial<Transaction> = { amountDecimal: 100 };
+
+describe('EmbeddedComponent', () => {
+  describe('creation', () => {
+    let component: EmbeddedComponent;
+    beforeEach(() => {
+      component = new EmbeddedComponent(url, { amountDecimal: 100 });
+    });
+
+    test('sets value', () => {
+      expect(component.value).toStrictEqual(value);
+    });
+
+    test('sets url', () => {
+      expect(component.url).toBe(url);
+    });
+  });
+
+  describe('iframe', () => {
+    let document: Document;
+    let parentElement: HTMLElement;
+    let iframe: HTMLIFrameElement;
+    let window: Window;
+    let iframeWindow: Window;
+
+    beforeEach(() => {
+      parentElement = {
+        appendChild: vi.fn(),
+      } as unknown as HTMLElement;
+
+      iframe = {
+        style: {},
+        src: '',
+        contentWindow: iframeWindow,
+        setAttribute: vi.fn(),
+        addEventListener: vi.fn(),
+      } as unknown as HTMLIFrameElement;
+
+      document = {
+        createElement: vi.fn().mockReturnValue(iframe),
+        querySelector: vi.fn().mockReturnValue(parentElement),
+      } as unknown as Document;
+
+      window = {
+        addEventListener: vi.fn(),
+      } as unknown as Window;
+
+      vi.stubGlobal('document', document);
+      vi.stubGlobal('window', window);
+    });
+
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    test('mount', () => {
+      const component = new EmbeddedComponent(url, value);
+      component.mount(parentId);
+      expect(iframe?.src).toBe(url);
+      expect(parentElement.appendChild).toHaveBeenCalledWith(iframe);
+    });
+
+    test('on', () => {
+      const component = new EmbeddedComponent(url, value);
+      const messageType = 'customEvent';
+      const callback = vi.fn();
+      component.on(messageType, callback);
+      component.mount(parentId);
+
+      // Simulate receiving a message of the specified type
+      // and assert that the callback is called with the correct payload.
+    });
+
+    test('off', () => {
+      const component = new EmbeddedComponent(url, value);
+      const messageType = 'customEvent';
+      const callback = vi.fn();
+      component.on(messageType, callback);
+
+      // Simulate receiving a message of the specified type
+      // and assert that the callback is called with the correct payload.
+
+      component.off(messageType, callback);
+
+      // Simulate receiving another message of the specified type
+      // and assert that the callback is not called.
+    });
+
+    describe('connected to iframe', () => {
+      let messageHandler: (event: MessageEvent) => void;
+      let port: MessagePort;
+      let handshake: MessageEvent;
+      let component: EmbeddedComponent;
+
+      beforeEach(() => {
+        port = {
+          postMessage: vi.fn(),
+          start: vi.fn(),
+          onmessage: null,
+        } as unknown as MessagePort;
+        handshake = {
+          source: iframe.contentWindow,
+          ports: [port],
+        } as unknown as MessageEvent;
+        window.addEventListener = vi
+          .fn()
+          .mockImplementation((event, handler) => {
+            messageHandler = handler;
+          });
+        component = new EmbeddedComponent(url, value);
+        component.mount(parentId);
+
+        expect(messageHandler).toBeDefined();
+        messageHandler(handshake);
+      });
+
+      test('send', () => {
+        const message: HostMessage = {
+          type: HMType.UPDATE,
+          value: { amountDecimal: 100 },
+        };
+        component.send(message);
+
+        // Assert that the message is sent to the embedded component
+        // and handled correctly.
+      });
+
+      test('update', () => {
+        const newValue: Partial<Transaction> = { amountDecimal: 200 };
+        component.update(newValue);
+
+        expect(component.value).toBe(newValue);
+      });
+
+      // TODO not sure this actually does what I want it to do
+      test('completion', async () => {
+        const response = { valid: true, value: 'completed' };
+        expect(port.onmessage).toBeDefined();
+
+        const promise = component.completion();
+        // @ts-expect-error - we've already verified that port exists
+        port.onmessage({
+          data: { type: CMType.COMPLETE, response },
+        } as MessageEvent);
+
+        promise.then((result) => {
+          expect(result).toBe(response);
+        });
+        return promise;
+        // Assert that the completion promise resolves with the expected response.
+      });
+    });
+  });
+});

package/src/ivms/types.ts

@@ -120,22 +120,38 @@ export type DateAndPlaceOfBirth = {
  * Address
  */
 export type Address = {
-  addressType?: AddressTypeCode;
-  department?: string; //Max50Text
-  subDepartment?: string; //Max70Text
-  streetName?: string; //Max70Text
-  buildingNumber?: string; //Max16Text
-  buildingName?: string; //Max35Text
-  floor?: string; //Max70Text
-  postBox?: string; //Max16Text
-  room?: string; //Max70Text
-  postCode?: string; //Max16Text
-  townName?: string; //Max35Text
-  townLocationName?: string; //Max35Text
-  districtName?: string; //Max35Text
-  countrySubDivision?: string; //Max35Text
-  addressLine?: string[]; //Max35Text max 7 items in array
-  country?: string; //CountryCode (^[A-Z]= {2}$)
+  /** Identifies the nature of the address. */
+  addressType: AddressTypeCode;
+  /** Identification of a division of a large organisation or building. */
+  department?: string;
+  /** Identification of a sub-division of a large organisation or building. */
+  subDepartment?: string;
+  /** Name of a street or thoroughfare. */
+  streetName?: string;
+  /** Number that identifies the position of a building on a street. */
+  buildingNumber?: string;
+  /** Name of the building or house. */
+  buildingName?: string;
+  /** Floor or storey within a building. */
+  floor?: string;
+  /** Numbered box in a post office. */
+  postBox?: string;
+  /** Building room number. */
+  room?: string;
+  /** Identifier consisting of a group of letters and/or numbers that is added to a postal address to assist the sorting of mail. */
+  postcode?: string;
+  /** Name of a built-up area, with defined boundaries, and a local government. */
+  townName: string;
+  /** Specific location name within the town. */
+  townLocationName?: string;
+  /** Identifies a subdivision within a country subdivision. */
+  districtName?: string;
+  /** Identifies a subdivision of a country such as state, region, province. */
+  countrySubDivision?: string;
+  /** Information that locates and identifies a specific address, presented in free format text. */
+  addressLine?: string[];
+  /** Nation with its own government. */
+  country: string;
 };
 
 /**
@@ -173,12 +189,18 @@ export type NaturalPersonName = {
  * NaturalPerson
  */
 export type NaturalPerson = {
-  name?: NaturalPersonName[];
+  /** The distinct words used as identification for an individual. */
+  name: NaturalPersonName;
+  /** The particulars of a location at which a person may be communicated with. */
   geographicAddress?: Address[];
+  /** A distinct identifier used by governments to uniquely identify a natural person. */
   nationalIdentification?: NationalIdentification;
-  customerIdentification?: string; //Max50Text
+  /** A distinct identifier that uniquely identifies the person to the institution in context. */
+  customerIdentification?: string;
+  /** Date and place of birth of a person. */
   dateAndPlaceOfBirth?: DateAndPlaceOfBirth;
-  countryOfResidence?: string; //CountryCode (^[A-Z]{2}$)
+  /** Country in which a person resides (the place of a person's home). */
+  countryOfResidence?: string;
 };
 
 /**
@@ -195,8 +217,10 @@ export type LocalLegalPersonNameID = {
  * LegalPersonNameID
  */
 export type LegalPersonNameID = {
-  legalPersonName?: string; //Max100Text
-  legalPersonNameIdentifierType?: LegalPersonNameTypeCode;
+  /** Name by which the legal person is known. */
+  legalPersonName: string;
+  /** The nature of the name specified. */
+  legalPersonNameIdentifierType: LegalPersonNameTypeCode;
 };
 
 /**
@@ -204,7 +228,7 @@ export type LegalPersonNameID = {
  * LegalPersonName
  */
 export type LegalPersonName = {
-  nameIdentifier?: LegalPersonNameID[];
+  nameIdentifier: LegalPersonNameID[];
   localNameIdentifier?: LocalLegalPersonNameID[];
   phoneticNameIdentifier?: LocalLegalPersonNameID[];
 };
@@ -214,11 +238,16 @@ export type LegalPersonName = {
  * LegalPerson
  */
 export type LegalPerson = {
-  name?: LegalPersonName;
+  /** The name of the legal person. */
+  name: LegalPersonName;
+  /** The address of the legal person. */
   geographicAddress?: Address[];
-  customerNumber?: string; //Max50Text
+  /** A distinct identifier that uniquely identifies the person to the institution in context. */
+  customerNumber?: string;
+  /** A distinct identifier used by governments to uniquely identify a legal person. */
   nationalIdentification?: NationalIdentification;
-  countryOfRegistration?: string; //CountryCode (^[A-Z]{2}$);
+  /** The country in which the legal person is registered. */
+  countryOfRegistration?: string;
 };
 
 /**
@@ -285,12 +314,26 @@ export type TransferPath = {
  * 6.7
  * Data describing the contents of the payload.
  */
-export type PayloadMetadata = {
-  transferPath?: TransliterationMethodCode[];
-};
+export interface PayloadMetadata {
+  /** The method used to map from a national system of writing to Latin script. */
+  transliterationMethod?: TransliterationMethodCode[];
+  /** The version of IVMS 101 to which the payload complies. */
+  payloadVersion: PayloadVersionCode;
+}
+/**
+ * The version of IVMS 101 to which the payload complies.
+ */
+export enum PayloadVersionCode {
+  /** Published May 2020 */
+  V101 = '101',
+  /** Published August 2023 */
+  V101_2023 = '101.2023',
+}
 
 /**
  * IVMS101 definition
+ *
+ * @public
  */
 export type IVMS101 = {
   originator?: Originator;