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

package/src/notabene.ts

@@ -1,318 +1,186 @@
-// @ts-ignore
-import { dom, node } from 'jsx-pragmatic';
-// @ts-ignore
-import zoid, { destroy } from 'zoid';
-import {
-  Fallback,
-  FieldsProps,
-  NonCustodialDeclarationType,
-  OptInFeature,
+import EmbeddedComponent from './components/EmbeddedComponent';
+import type {
+  Agent,
+  AgentType,
+  CallbackOptions,
+  ComponentMessage,
+  Counterparty,
+  DeclarationProof,
+  Deposit,
+  DepositRequest,
+  Destination,
+  HostMessage,
+  IVMS101,
+  MicroTransferProof,
+  OwnershipProof,
+  PersonType,
+  ProofStatus,
+  ProofTypes,
+  ScreenshotProof,
+  SignatureProof,
+  Status,
   Theme,
   Transaction,
-  TransactionTypeAllowed,
-  WidgetType,
+  TransactionAsset,
+  TransactionOptions,
+  VASP,
+  Wallet,
+  Withdrawal,
 } from './types';
-import { popupProps, widgetProps } from './zoidComponentProps';
-
-interface NotabeneConfig {
-  widget: string;
-  container: string;
-  authToken: string;
-  vaspDID: string;
-  onValidStateChange(isValid: boolean): void;
-  onError(err: any): void;
+import { CMType, TransactionResponse } from './types';
+import { encodeObjectToFragment } from './utils/urls';
+
+export type {
+  CMType,
+  ComponentMessage,
+  EmbeddedComponent,
+  HostMessage,
+  Theme,
+  Counterparty,
+  Withdrawal,
+  Deposit,
+  Transaction,
+  DepositRequest,
+  TransactionResponse,
+  Destination as destination,
+  TransactionAsset,
+  SignatureProof,
+  ScreenshotProof,
+  MicroTransferProof,
+  DeclarationProof,
+  Notabene,
+  ProofStatus,
+  ProofTypes,
+  IVMS101,
+  PersonType,
+  Status,
+  VASP,
+  Wallet,
+  Agent,
+  AgentType,
+  OwnershipProof,
+  TransactionOptions,
+};
+
+/**
+ * Configuration for the Notabene SDK
+ *
+ * @public
+ */
+export interface NotabeneConfig {
+  nodeUrl?: string;
+  authToken?: string;
+  uxUrl?: string;
   theme?: Theme;
-  dictionary?: { [key: string]: string };
-  transactionTypeAllowed?: TransactionTypeAllowed;
-  nonCustodialDeclarationType?: NonCustodialDeclarationType;
-  beneficiaryDetails?: string[]; // @deprecated beneficiaryDetails - do not delete yet
-  fieldsProps?: FieldsProps;
-  fallbacks?: Fallback[];
-  optInFeatures?: OptInFeature[];
+  locale?: string;
 }
 
+/**
+ * Primary constructor for Notabene UX elements
+ *
+ * @public
+ */
+
 export default class Notabene {
-  private widget: zoid.ZoidComponent;
-  private popup: zoid.ZoidComponent;
-  private config: NotabeneConfig;
-  private tx: Transaction | undefined;
-  private error?: Error;
-  private widgetRendered: boolean;
-  private popupRendered: boolean;
-  private shouldBeDestroyed: boolean;
+  private nodeUrl?: string;
+  private authToken?: string;
+  private uxUrl: string;
+  private theme?: Theme;
+  private locale?: string;
 
   constructor(config: NotabeneConfig) {
-    this.config = config;
-    this.config.nonCustodialDeclarationType =
-      config.nonCustodialDeclarationType || 'SIGNATURE';
-    this.config.transactionTypeAllowed = config.transactionTypeAllowed || 'ALL';
-    this.widgetRendered = false;
-    this.shouldBeDestroyed = false;
-    this.popupRendered = false;
-    this.config.fallbacks = this.config.fallbacks || [
-      { flow: 'WALLET_NOT_SUPPORTED', action: 'DECLARATION' },
-    ];
-  }
-
-  /**
-   * Renders a new widget
-   * @param type - the type of widget to render
-   */
-  public async renderWidget(
-    type: WidgetType = WidgetType.WITHDRAWAL
-  ): Promise<void> {
-    this._renderWidget(type);
+    this.uxUrl = config.uxUrl || 'https://connect.notabene.id';
+    this.nodeUrl = config.nodeUrl;
+    this.authToken = config.authToken;
+    this.theme = config.theme;
+    this.locale = config.locale;
   }
 
-  private async _renderWidget(type: WidgetType): Promise<void> {
-    if (this.widgetRendered) {
-      console.error(
-        'Notabene: Widget already rendered, please destroy it first'
-      );
-      this.config.onError(
-        new Error('Widget already rendered, please destroy it first')
-      );
-      return;
-    }
-
-    this.widget = await this.buildWidget();
-    this.popup = await this.buildPopup();
-    this.widget.updateProps({
-      transaction: this.tx,
-      type,
-    });
-    this.popup.updateProps({
-      transaction: this.tx,
-      type,
+  public componentUrl(
+    path: string,
+    value: Partial<Transaction>,
+    configuration?: TransactionOptions,
+    callbacks?: CallbackOptions,
+  ): string {
+    const url = new URL(this.uxUrl);
+    url.pathname = path;
+
+    const hash = encodeObjectToFragment({
+      authToken: this.authToken,
+      value,
+      configuration,
     });
-    this.popup.hide();
-    await this.widget.render(this.config.container);
-    await this.renderPopup();
-  }
-
-  private async renderPopup(): Promise<void> {
-    if (!this.popup) return;
+    url.hash = hash;
+    if (this.nodeUrl) url.searchParams.set('nodeUrl', this.nodeUrl);
 
-    if (!this.popupRendered) {
-      await this.popup.render(this.config.container);
-      this.popupRendered = true;
+    if (this.theme) {
+      url.searchParams.set('theme', JSON.stringify(this.theme));
     }
-  }
-
-  public async destroyWidget(): Promise<void> {
-    if (!this.widgetRendered || !this.popupRendered) {
-      this.shouldBeDestroyed = true;
-      return;
+    if (this.locale) {
+      url.searchParams.set('locale', this.locale);
     }
-    await destroy();
-    this.shouldBeDestroyed = false;
-    this.widgetRendered = false;
-    this.popupRendered = false;
-  }
-
-  public setTransaction(tx: Transaction) {
-    this.tx = tx;
-    if (this.widgetRendered) {
-      this.widget.updateProps({
-        transaction: tx,
-      });
-      this.popup.updateProps({
-        transaction: tx,
-      });
+    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();
   }
 
-  private cleanUpDestroyedComponents() {
-    if (!this.shouldBeDestroyed) return;
-    this.destroyWidget();
+  public createComponent(
+    path: string,
+    value: Partial<Transaction>,
+    options?: TransactionOptions,
+    callbacks?: CallbackOptions,
+  ) {
+    return new EmbeddedComponent(
+      this.componentUrl(path, value, options, callbacks),
+      value,
+    );
   }
 
-  private getWidgetUrl(): string {
-    const url = new URL(this.config.widget);
-    url.hash = `authToken=${this.config.authToken}`;
-    return url.toString();
+  public createWithdrawalAssist(
+    value: Partial<Withdrawal>,
+    options?: TransactionOptions,
+    callbacks?: CallbackOptions,
+  ) {
+    return this.createComponent('withdrawal-assist', value, options, callbacks);
   }
 
-  private getAdditionalInfoUrl(): string {
-    const url = new URL(this.config.widget);
-    url.search = 'popup=true';
-    url.hash = `authToken=${this.config.authToken}`;
-
-    return url.toString();
+  public createDepositAssist(
+    value: Partial<Deposit>,
+    options?: any,
+    callbacks?: CallbackOptions,
+  ) {
+    return this.createComponent('deposit-assist', value, options, callbacks);
   }
 
-  private handleError(err: any): void {
-    this.error = err;
-    if (this.widget && this.popup) {
-      this.widget.updateProps({
-        error: err,
-      });
-      this.popup.updateProps({
-        error: err,
-      });
-    }
-    if (!err || !this.config.onError) return;
-    this.config.onError(err);
+  public createConnect(
+    value: Partial<Withdrawal>,
+    options?: TransactionOptions,
+    callbacks?: CallbackOptions,
+  ) {
+    return this.createComponent('connect', value, options, callbacks);
   }
 
-  private buildWidget(): zoid.ZoidComponent {
-    if (!this.config.authToken) {
-      console.error('Notabene: authToken is required');
-      return;
-    }
-
-    const builtWidget = zoid.create({
-      tag: 'widget',
-      url: this.getWidgetUrl(),
-      dimensions: {
-        width: '100%',
-        height: '280px',
-      },
-      attributes: {
-        iframe: {
-          allow: 'usb *;bluetooth *',
-        },
-      },
-      props: widgetProps,
-    })({
-      vaspDID: this.config.vaspDID,
-      transaction: {},
-      theme: this.config.theme,
-      dictionary: this.config.dictionary,
-      transactionTypeAllowed: this.config.transactionTypeAllowed,
-      nonCustodialDeclarationType: this.config.nonCustodialDeclarationType,
-      beneficiaryDetails: this.config.beneficiaryDetails,
-      fieldsProps: this.config.fieldsProps,
-      fallbacks: this.config.fallbacks,
-      optInFeatures: this.config.optInFeatures,
-      onRequireAdditionalInformation: () => {
-        this.popup.updateProps({
-          popupOpen: true,
-        });
-        this.popup.show();
-      },
-      onValidStateChange: (isValid: boolean) => {
-        this.config.onValidStateChange(isValid);
-      },
-      error: this.error,
-      onError: (err: any) => {
-        this.handleError(err);
-        console.debug('Notabene: Error handler called');
-      },
-      storeTransaction: (tx: Transaction) => {
-        this.setTransaction(tx);
-      },
-    });
-
-    builtWidget.event.on(zoid.EVENT.RENDERED, () => {
-      this.widgetRendered = true;
-      this.cleanUpDestroyedComponents();
-    });
-
-    return builtWidget;
+  public createDepositRequest(
+    value: Partial<DepositRequest>,
+    options?: TransactionOptions,
+    callbacks?: CallbackOptions,
+  ) {
+    return this.createComponent('deposit-request', value, options, callbacks);
   }
 
-  private buildPopup(): zoid.ZoidComponent {
-    if (!this.config.authToken) {
-      console.error('Notabene: authToken is required');
-      return;
-    }
-
-    const builtPopup = zoid.create({
-      tag: 'popup',
-      url: this.getAdditionalInfoUrl(),
-      children: () => {
-        return {
-          Transaction: this.tx,
-        };
+  public decodeFragmentToObject(fragment: string): Record<string, string> {
+    const pairs = fragment.slice(1).split('&');
+    return pairs.reduce(
+      (obj, pair) => {
+        const [key, value] = pair.split('=');
+        obj[decodeURIComponent(key)] = decodeURIComponent(value);
+        return obj;
       },
-      dimensions: {
-        width: '100%',
-        height: '100%',
-      },
-      attributes: {
-        iframe: {
-          allow: 'usb *;bluetooth *',
-        },
-      },
-      props: popupProps,
-      containerTemplate: ({ uid, doc, frame, prerenderFrame }: any) => {
-        return node(
-          'div',
-          { id: uid, class: 'nb-container' },
-          node(
-            'style',
-            null,
-            `
-            #${uid}.container {
-                border: 5px solid red;
-            }
-            .nb-overlay {
-              position: fixed;
-              width: 100vw;
-              height: 100vh;
-              top: 0;
-              left: 0;
-              display: flex;
-              align-items: center;
-              justify-content: center;
-              background-color: rgba(0,0,0,0.5);
-            }
-            .nb-popup {
-              width: 100%;
-              height: 100%;
-            }
-            .nb-preloader {
-              display: none;
-            }
-          `
-          ),
-          node(
-            'div',
-            { class: 'nb-overlay' },
-            node('node', { el: frame, class: 'nb-popup' }),
-            node('node', { el: prerenderFrame, class: 'nb-preloader' })
-          )
-        ).render(dom({ doc }));
-      },
-    })({
-      vaspDID: this.config.vaspDID,
-      transaction: this.tx,
-      beneficiaryDetails: this.config.beneficiaryDetails,
-      fieldsProps: this.config.fieldsProps,
-      storeTransaction: (tx: Transaction) => {
-        this.setTransaction(tx);
-        console.debug('Notabene: Transaction stored');
-      },
-      close: () => {
-        this.popup.close();
-        console.debug('Notabene: Popup closing');
-      },
-      setPopupOpen: (isOpen: boolean) => {
-        this.popup.updateProps({
-          popupOpen: isOpen,
-        });
-      },
-      error: this.error,
-      onError: (err: any) => {
-        this.handleError(err);
-        console.debug('Notabene: Error handler called');
-      },
-      popupOpen: false,
-      theme: this.config.theme,
-      dictionary: this.config.dictionary,
-      transactionTypeAllowed: this.config.transactionTypeAllowed,
-      nonCustodialDeclarationType: this.config.nonCustodialDeclarationType,
-      fallbacks: this.config.fallbacks,
-      optInFeatures: this.config.optInFeatures,
-    });
-
-    builtPopup.event.on(zoid.EVENT.RENDERED, () => {
-      this.popupRendered = true;
-      this.cleanUpDestroyedComponents();
-    });
-    return builtPopup;
+      {} as Record<string, string>,
+    );
   }
 }
-
-if (window) window.Notabene = Notabene;