edfapay-softpos-sdk-rn 1.0.0

package/src/namespaces/Extension.ts

@@ -0,0 +1,194 @@
+import { EdfaPayBridge } from '../bridge';
+import { Location } from '../models/Location';
+import { FunctionCode } from '../enums/FunctionCode';
+import type {
+  OnSuccessCallback,
+  OnErrorCallback,
+  OnTerminalBindingTask,
+} from '../types';
+
+/// EdfaPayPlugin.Extension — advanced methods for custom integrations.
+/// Matches: EdfaPayPlugin.Extension in native SDK.
+export class PluginExtension {
+  private constructor() {}
+
+  static create(): PluginExtension {
+    return new PluginExtension();
+  }
+
+  init(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.init', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+
+  loginWithCredentials(params: {
+    email: string;
+    password: string;
+    location: Location;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.loginWithCredentials',
+      { email: params.email, password: params.password, location: params.location.toJSON() },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  loginWithToken(params: {
+    token: string;
+    location: Location;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.loginWithToken',
+      { token: params.token, location: params.location.toJSON() },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  verifyOtp(params: {
+    sessionId: string;
+    otp: string;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.verifyOtp',
+      { sessionId: params.sessionId, otp: params.otp },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  resendOtp(params: {
+    sessionId: string;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.resendOtp',
+      { sessionId: params.sessionId },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  getAvailableTerminal(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.getAvailableTerminal', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+
+  registerTerminal(params: {
+    trsm: string;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.registerTerminal',
+      { trsm: params.trsm },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  getTerminalConfig(params: {
+    forceDownload?: boolean;
+    configurationType?: FunctionCode;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.getTerminalConfig',
+      {
+        forceDownload: params.forceDownload ?? false,
+        configurationType: params.configurationType ?? FunctionCode.FULL_TERMINAL_CONFIGURATION,
+      },
+      {
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  getInitialKey(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.getInitialKey', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+
+  renewSessionIfRequiredAndPossible(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.renewSessionIfRequiredAndPossible', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+
+  initKernels(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.initKernels', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+
+  prepareTerminalWithToken(params: {
+    token: string;
+    location: Location;
+    onTerminalBindingTask: OnTerminalBindingTask;
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Extension.prepareTerminalWithToken',
+      { token: params.token, location: params.location.toJSON() },
+      {
+        onTerminalBindingTask: params.onTerminalBindingTask,
+        onSuccess: params.onSuccess,
+        onError: params.onError,
+      },
+    );
+  }
+
+  getUserInfo(params: {
+    onSuccess: OnSuccessCallback;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke('Extension.getUserInfo', {}, {
+      onSuccess: params.onSuccess,
+      onError: params.onError,
+    });
+  }
+}

package/src/namespaces/RemoteChannel.ts

@@ -0,0 +1,43 @@
+import { EdfaPayBridge } from '../bridge';
+
+/// Builder returned by RemoteAccess.LocalNetwork(...). Call .open() to start.
+export class LocalNetworkChannel {
+  constructor(
+    private readonly port: number,
+    private readonly timeout: number,
+  ) {}
+
+  open(): void {
+    EdfaPayBridge.invoke('RemoteChannel.LocalNetwork.open', {
+      port: this.port,
+      timeout: this.timeout,
+    });
+  }
+
+  close(): void {
+    EdfaPayBridge.invoke('RemoteChannel.LocalNetwork.close', {});
+  }
+}
+
+/// EdfaPayPlugin.RemoteChannel — local network remote access.
+/// Matches: EdfaPayPlugin.RemoteChannel in native SDK.
+export class RemoteAccess {
+  private constructor() {}
+
+  static create(): RemoteAccess {
+    return new RemoteAccess();
+  }
+
+  /**
+   * Configure and return a local network channel builder.
+   * Usage: EdfaPayPlugin.RemoteChannel.LocalNetwork({ port: 8080, timeout: 30 }).open()
+   */
+  LocalNetwork(params: { port: number; timeout: number }): LocalNetworkChannel {
+    return new LocalNetworkChannel(params.port, params.timeout);
+  }
+
+  /** Alias with camelCase for idiomatic TS: .localNetwork(...) */
+  localNetwork(params: { port: number; timeout: number }): LocalNetworkChannel {
+    return this.LocalNetwork(params);
+  }
+}

package/src/namespaces/Utils.ts

@@ -0,0 +1,91 @@
+import { EdfaPayBridge } from '../bridge';
+import { Location } from '../models/Location';
+import type { OnErrorCallback } from '../types';
+
+/// EdfaPayPlugin.Utils — device and location utilities.
+/// Matches: EdfaPayPlugin.Utils in native SDK.
+export class PluginUtils {
+  private constructor() {}
+
+  static create(): PluginUtils {
+    return new PluginUtils();
+  }
+
+  /// Returns unique device identifier.
+  async getDeviceId(merchantId?: number): Promise<string | null> {
+    const result = await EdfaPayBridge.invokeAsync('Utils.getDeviceId', { merchantId });
+    return result as string | null;
+  }
+
+  /// Returns true if location permission is granted.
+  async haveLocationPermission(): Promise<boolean> {
+    const result = await EdfaPayBridge.invokeAsync('Utils.haveLocationPermission');
+    return (result as boolean) ?? false;
+  }
+
+  /// Requests location permission. [callback] receives true if granted.
+  requestLocationPermission(params: { callback: (permitted: boolean) => void }): void {
+    EdfaPayBridge.invoke('Utils.requestLocationPermission', {}, {
+      onSuccess: (p: Record<string, any>) => params.callback((p['permitted'] as boolean) ?? false),
+    });
+  }
+
+  /// Gets current device location.
+  /// [completion] receives (location Map?, hasPermission).
+  currentLocation(params: {
+    completion: (location: Record<string, any> | null, hasPermission: boolean) => void;
+  }): void {
+    EdfaPayBridge.invoke('Utils.currentLocation', {}, {
+      onSuccess: (p: Record<string, any>) =>
+        params.completion(
+          p['location'] as Record<string, any> | null,
+          (p['permission'] as boolean) ?? false,
+        ),
+    });
+  }
+
+  /// Checks if [location] is mocked/fake.
+  async isLocationMocked(location: Location): Promise<boolean> {
+    const result = await EdfaPayBridge.invokeAsync('Utils.isLocationMocked', {
+      location: location.toJSON(),
+    });
+    return (result as boolean) ?? false;
+  }
+
+  /// Shows an SDK-styled message dialog.
+  showMessageDialog(params: {
+    title: string;
+    message: string;
+    onClose?: () => void;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Utils.showMessageDialog',
+      { title: params.title, message: params.message },
+      params.onClose ? { onSuccess: (_: any) => params.onClose!() } : undefined,
+    );
+  }
+
+  /// Saves a value encrypted to DataStore.
+  saveData(params: {
+    key: string;
+    value: string;
+    onSuccess: (success: boolean) => void;
+    onError: OnErrorCallback;
+  }): void {
+    EdfaPayBridge.invoke(
+      'Utils.saveData',
+      { key: params.key, value: params.value },
+      {
+        onSuccess: (p: Record<string, any>) =>
+          params.onSuccess((p['success'] as boolean) ?? false),
+        onError: params.onError,
+      },
+    );
+  }
+
+  /// Retrieves a value from encrypted DataStore.
+  async getData(key: string): Promise<string | null> {
+    const result = await EdfaPayBridge.invokeAsync('Utils.getData', { key });
+    return result as string | null;
+  }
+}

package/src/types.ts

@@ -0,0 +1,30 @@
+import { Terminal } from './models/Terminal';
+import { TerminalBindingTask } from './models/TerminalBindingTask';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Callback type aliases — mirror native Kotlin typealiases exactly
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type ProcessCompleteCallback = (
+  status: boolean,
+  code: string | null,
+  transaction: Record<string, any> | null,
+  isFlowComplete: boolean
+) => void;
+
+/** Alias for ProcessCompleteCallback — mirrors Dart's onProcessComplete typedef */
+export type OnProcessComplete = ProcessCompleteCallback;
+
+export type TimeOutCallback = () => void;
+
+export type CancelByUserCallback = () => void;
+
+export type OnErrorCallback = (error: Record<string, any>) => void;
+
+export type OnSuccessCallback = (result: Record<string, any>) => void;
+
+export type OnTerminalBindingTask = (task: TerminalBindingTask) => void;
+export type OnTerminalRefresh = (
+  error: Record<string, any>,
+  list: Terminal[]
+) => void;