@notabene/javascript-sdk 1.34.0 → 2.0.0-next.2

package/ts-out/src/components/__tests__/EmbeddedComponent.test.js

@@ -0,0 +1,132 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { CMType, HMType } from '../../types';
+import EmbeddedComponent from '../EmbeddedComponent';
+const url = 'https://example.com';
+const parentId = 'parent-container';
+const value = { amountDecimal: 100 };
+describe('EmbeddedComponent', () => {
+    describe('creation', () => {
+        let component;
+        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;
+        let parentElement;
+        let iframe;
+        let window;
+        let iframeWindow;
+        beforeEach(() => {
+            parentElement = {
+                appendChild: vi.fn(),
+            };
+            iframe = {
+                style: {},
+                src: '',
+                contentWindow: iframeWindow,
+                setAttribute: vi.fn(),
+                addEventListener: vi.fn(),
+            };
+            document = {
+                createElement: vi.fn().mockReturnValue(iframe),
+                querySelector: vi.fn().mockReturnValue(parentElement),
+            };
+            window = {
+                addEventListener: vi.fn(),
+            };
+            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;
+            let port;
+            let handshake;
+            let component;
+            beforeEach(() => {
+                port = {
+                    postMessage: vi.fn(),
+                    start: vi.fn(),
+                    onmessage: null,
+                };
+                handshake = {
+                    source: iframe.contentWindow,
+                    ports: [port],
+                };
+                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 = {
+                    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 = { 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 },
+                });
+                promise.then((result) => {
+                    expect(result).toBe(response);
+                });
+                return promise;
+                // Assert that the completion promise resolves with the expected response.
+            });
+        });
+    });
+});

package/ts-out/src/ivms/types.d.ts

@@ -0,0 +1,252 @@
+/**
+ * 5.3.8
+ * NaturalPersonNameTypeCode
+ *
+ * `ALIA` Alias name  - A name other than the legal name by which a natural person is also known.
+ * `BIRT` Name at birth - The name given to a natural person at birth.
+ * `MAID` Maiden name - The original name of a natural person who has changed their name after marriage.
+ * `LEGL` Legal name - The name that identifies a natural person for legal, official or administrative purposes.
+ * `MISC` Unspecified - A name by which a natural person may be known but which cannot otherwise be categorized or the category of which the sender is unable to determine.
+ */
+export type NaturalPersonNameTypeCode = 'ALIA' | 'BIRT' | 'MAID' | 'LEGL' | 'MISC';
+/**
+ * 5.3.9
+ * LegalPersonNameTypeCode
+ *
+ * `LEGL` Legal name - Official name under which an organisation is registered.
+ * `SHRT` Short name - Specifies the short name of the organisation.
+ * `TRAD` Trading name - Name used by a business for commercial purposes, although its registered legal name, used for contracts and other formal situations, may be another.
+ */
+export type LegalPersonNameTypeCode = 'LEGL' | 'SHRT' | 'TRAD';
+/**
+ * 5.3.11
+ * AddressTypeCode
+ *
+ * `HOME` Residential - Address is the home address.
+ * `BIZZ` Business - Address is the business address.
+ * `GEOG` Geographic - Address is the unspecified physical (geographical) address suitable for identification of the natural or legal person.
+ */
+export type AddressTypeCode = 'HOME' | 'BIZZ' | 'GEOG';
+/**
+ * 5.3.14
+ * NationalIdentifierTypeCode
+ *
+ * `ARNU` Alien registration number - Number assigned by a government agency to identify foreign nationals.
+ * `CCPT` Passport number - Number assigned by a passport authority.
+ * `RAID` Registration authority identifier - Identifier of a legal entity as maintained by a registration authority.
+ * `DRLC` Driver license number - Number assigned to a driver's license.
+ * `FIIN` Foreign investment identity number - Number assigned to a foreign investor (other than the alien number).
+ * `TXID` Tax identification number - Number assigned by a tax authority to an entity.
+ * `SOCS` Social security number - Number assigned by a social security agency.
+ * `IDCD` Identity card number - Number assigned by a national authority to an identity card.
+ * `LEIX` Legal Entity Identifier - Legal Entity Identifier (LEI) assigned in accordance with ISO 17442 11 .
+ * `MISC` Unspecified - A national identifier which may be known but which cannot otherwise be categorized or the category of which the sender is unable to determine.
+ */
+export type NationalIdentifierTypeCode = 'ARNU' | 'CCPT' | 'RAID' | 'DRLC' | 'FIIN' | 'TXID' | 'SOCS' | 'IDCD' | 'LEIX' | 'MISC';
+/**
+ * 5.3.16
+ * TransliterationMethodCode
+ *
+ * `arab` Arabic (Arabic language) - ISO 233-2:1993
+ * `aran` Arabic (Persian language) - ISO 233-3:1999
+ * `armn` Armenian - ISO 9985:1996
+ * `cyrl` Cyrillic - ISO 9:1995
+ * `deva` Devanagari & related Indic - ISO 15919:2001
+ * `geor` Georgian - ISO 9984:1996
+ * `grek` Greek - ISO 843:1997
+ * `hani` Han (Hanzi, Kanji, Hanja) - ISO 7098:2015
+ * `hebr` Hebrew - ISO 259-2:1994
+ * `kana` Kana - ISO 3602:1989
+ * `kore` Korean - Revised Romanization of Korean
+ * `thai` Thai - ISO 11940-2:2007
+ * `othr` Script other than those listed above - Unspecified
+ */
+export type TransliterationMethodCode = 'arab' | 'aran' | 'armn' | 'cyrl' | 'deva' | 'geor' | 'grek' | 'hani' | 'hebr' | 'kana' | 'kore' | 'thai' | 'othr';
+/**
+ * 5.2.8
+ * NationalIdentification
+ */
+export type NationalIdentification = {
+    nationalIdentifier?: string;
+    nationalIdentifierType?: NationalIdentifierTypeCode;
+    countryOfIssue?: string;
+    registrationAuthority?: string;
+};
+/**
+ * 5.2.7
+ * DateAndPlaceOfBirth
+ */
+export type DateAndPlaceOfBirth = {
+    dateOfBirth?: string;
+    placeOfBirth?: string;
+};
+/**
+ * 5.2.6
+ * Address
+ */
+export type Address = {
+    addressType?: AddressTypeCode;
+    department?: string;
+    subDepartment?: string;
+    streetName?: string;
+    buildingNumber?: string;
+    buildingName?: string;
+    floor?: string;
+    postBox?: string;
+    room?: string;
+    postCode?: string;
+    townName?: string;
+    townLocationName?: string;
+    districtName?: string;
+    countrySubDivision?: string;
+    addressLine?: string[];
+    country?: string;
+};
+/**
+ * 5.2.5
+ * LocalNaturalPersonNameID
+ */
+export type LocalNaturalPersonNameID = {
+    primaryIdentifier?: string;
+    secondaryIdentifier?: string;
+    nameIdentifierType?: NaturalPersonNameTypeCode;
+};
+/**
+ * 5.2.4
+ * NaturalPersonNameID
+ */
+export type NaturalPersonNameID = {
+    primaryIdentifier?: string;
+    secondaryIdentifier?: string;
+    nameIdentifierType?: NaturalPersonNameTypeCode;
+};
+/**
+ * 5.2.3
+ * NaturalPersonName
+ */
+export type NaturalPersonName = {
+    nameIdentifier?: NaturalPersonNameID[];
+    localNameIdentifier?: LocalNaturalPersonNameID[];
+    phoneticNameIdentifier?: LocalNaturalPersonNameID[];
+};
+/**
+ * 5.2.2
+ * NaturalPerson
+ */
+export type NaturalPerson = {
+    name?: NaturalPersonName[];
+    geographicAddress?: Address[];
+    nationalIdentification?: NationalIdentification;
+    customerIdentification?: string;
+    dateAndPlaceOfBirth?: DateAndPlaceOfBirth;
+    countryOfResidence?: string;
+};
+/**
+ * 5.2.12
+ * LocalLegalPersonNameID
+ */
+export type LocalLegalPersonNameID = {
+    legalPersonName?: string;
+    legalPersonNameIdentifierType?: LegalPersonNameTypeCode;
+};
+/**
+ * 5.2.11
+ * LegalPersonNameID
+ */
+export type LegalPersonNameID = {
+    legalPersonName?: string;
+    legalPersonNameIdentifierType?: LegalPersonNameTypeCode;
+};
+/**
+ * 5.2.10
+ * LegalPersonName
+ */
+export type LegalPersonName = {
+    nameIdentifier?: LegalPersonNameID[];
+    localNameIdentifier?: LocalLegalPersonNameID[];
+    phoneticNameIdentifier?: LocalLegalPersonNameID[];
+};
+/**
+ * 5.2.9
+ * LegalPerson
+ */
+export type LegalPerson = {
+    name?: LegalPersonName;
+    geographicAddress?: Address[];
+    customerNumber?: string;
+    nationalIdentification?: NationalIdentification;
+    countryOfRegistration?: string;
+};
+/**
+ * 5.2.1
+ * Person
+ */
+export type Person = {
+    naturalPerson?: NaturalPerson;
+    legalPerson?: LegalPerson;
+};
+/**
+ * 5.2.13
+ * IntermediaryVASP
+ */
+export type IntermediaryVASP = {
+    intermediaryVASP?: Person;
+    sequence?: number;
+};
+/**
+ * 6.2
+ * The originator is defined in Section 1.1 as the account holder who allows the VA transfer from that account or, where there is no account, the natural or legal person that places the order with the originating VASP to perform the VA transfer.
+ */
+export type Originator = {
+    originatorPersons?: Person[];
+    accountNumber?: string[];
+};
+/**
+ * 6.3
+ * The beneficiary is defined in Section 1.1 as the natural or legal person or legal arrangement who is identified by the originator as the receiver of the requested VA transfer.
+ */
+export type Beneficiary = {
+    beneficiaryPersons?: Person[];
+    accountNumber?: string[];
+};
+/**
+ * 6.4
+ * The originating VASP is defined in Section 1.1 as the VASP which initiates the VA transfer, and transfers the VA upon receiving the request for a VA transfer on behalf of the originator.
+ */
+export type OriginatingVASP = {
+    originatingVASP?: Person;
+};
+/**
+ * 6.5
+ * The originating VASP is defined in Section 1.1 as the VASP which initiates the VA transfer, and transfers the VA upon receiving the request for a VA transfer on behalf of the originator.
+ */
+export type BeneficiaryVASP = {
+    beneficiaryVASP?: Person;
+};
+/**
+ * 6.6
+ * The transfer path refers to the intermediary VASP(s) participating in a serial chain that receive(s) and retransmit(s) a VA transfer on behalf of the originating VASP and the beneficiary VASP, or another intermediary VASP, together with their corresponding sequence number.
+ */
+export type TransferPath = {
+    transferPath?: IntermediaryVASP[];
+};
+/**
+ * 6.7
+ * Data describing the contents of the payload.
+ */
+export type PayloadMetadata = {
+    transferPath?: TransliterationMethodCode[];
+};
+/**
+ * IVMS101 definition
+ *
+ * @public
+ */
+export type IVMS101 = {
+    originator?: Originator;
+    beneficiary?: Beneficiary;
+    originatingVASP?: OriginatingVASP;
+    beneficiaryVASP?: BeneficiaryVASP;
+    transferPath?: TransferPath;
+    payloadMetadata?: PayloadMetadata;
+};

package/ts-out/src/ivms/types.js

@@ -0,0 +1 @@
+export {};

package/ts-out/src/notabene.d.ts

@@ -0,0 +1,35 @@
+import EmbeddedComponent from './components/EmbeddedComponent';
+import type { Agent, AgentType, CallbackOptions, ComponentMessage, Counterparty, DeclarationProof, Destination, HostMessage, IVMS101, MicroTransferProof, OwnershipProof, PersonType, ProofStatus, ProofTypes, ScreenshotProof, SignatureProof, Status, Theme, Transaction, TransactionAsset, VASP, Wallet, Withdrawal } from './types';
+import { CMType, TransactionResponse } from './types';
+export type { CMType, ComponentMessage, EmbeddedComponent, HostMessage, Theme, Counterparty, Withdrawal, Transaction, TransactionResponse, Destination as destination, TransactionAsset, SignatureProof, ScreenshotProof, MicroTransferProof, DeclarationProof, Notabene, ProofStatus, ProofTypes, IVMS101, PersonType, Status, VASP, Wallet, Agent, AgentType, OwnershipProof, };
+/**
+ * Configuration for the Notabene SDK
+ *
+ * @public
+ */
+export interface NotabeneConfig {
+    nodeUrl: string;
+    authToken: string;
+    uxUrl?: string;
+    theme?: Theme;
+    dictionary?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Primary constructor for Notabene UX elements
+ *
+ * @public
+ */
+export default class Notabene {
+    private nodeUrl;
+    private authToken;
+    private uxUrl;
+    private theme?;
+    private dictionary?;
+    constructor(config: NotabeneConfig);
+    componentUrl(path: string, value: Partial<Transaction>, configuration?: any, callbacks?: CallbackOptions): string;
+    createComponent(path: string, value: Partial<Transaction>, options?: any, callbacks?: CallbackOptions): EmbeddedComponent;
+    createWithdrawalAssist(value: Partial<Withdrawal>, options?: any, callbacks?: CallbackOptions): EmbeddedComponent;
+    decodeFragmentToObject(fragment: string): Record<string, string>;
+}

package/ts-out/src/notabene.js

@@ -0,0 +1,59 @@
+import EmbeddedComponent from './components/EmbeddedComponent';
+import { encodeObjectToFragment } from './utils/urls';
+/**
+ * Primary constructor for Notabene UX elements
+ *
+ * @public
+ */
+export default class Notabene {
+    nodeUrl;
+    authToken;
+    uxUrl;
+    theme;
+    dictionary;
+    constructor(config) {
+        this.uxUrl = config.uxUrl || 'https://ux.notabene.id';
+        this.nodeUrl = config.nodeUrl;
+        this.authToken = config.authToken;
+        this.theme = config.theme;
+        this.dictionary = config.dictionary;
+    }
+    componentUrl(path, value, configuration, callbacks) {
+        const url = new URL(this.uxUrl);
+        url.pathname = path;
+        const hash = encodeObjectToFragment({
+            authToken: this.authToken,
+            value,
+            configuration,
+        });
+        url.hash = hash;
+        url.searchParams.set('nodeUrl', this.nodeUrl);
+        if (this.theme) {
+            url.searchParams.set('theme', JSON.stringify(this.theme));
+        }
+        if (this.dictionary) {
+            url.searchParams.set('dictionary', JSON.stringify(this.dictionary));
+        }
+        if (callbacks) {
+            if (callbacks.callback)
+                url.searchParams.set('callback_url', callbacks.callback);
+            if (callbacks.redirectUri)
+                url.searchParams.set('redirect_uri', callbacks.redirectUri);
+        }
+        return url.toString();
+    }
+    createComponent(path, value, options, callbacks) {
+        return new EmbeddedComponent(this.componentUrl(path, value, options, callbacks), value);
+    }
+    createWithdrawalAssist(value, options, callbacks) {
+        return this.createComponent('withdrawal-assist', value, options, callbacks);
+    }
+    decodeFragmentToObject(fragment) {
+        const pairs = fragment.slice(1).split('&');
+        return pairs.reduce((obj, pair) => {
+            const [key, value] = pair.split('=');
+            obj[decodeURIComponent(key)] = decodeURIComponent(value);
+            return obj;
+        }, {});
+    }
+}