@achyutlabsau/vue-payment-gateway 0.0.1

package/dist/smartpay.d.ts

@@ -0,0 +1,142 @@
+export declare const DEV_SMARTPAY_API_URL = "https://api-dev.smart-connect.cloud/POS";
+
+export declare interface PairingParams {
+    POSRegisterID: string;
+    POSRegisterName: string;
+    POSBusinessName: string;
+    POSVendorName: string;
+    "Contact Name"?: string;
+    Address?: string;
+    City?: string;
+    State?: string;
+    ZipCode?: string;
+    Email?: string;
+    Phone?: string;
+}
+
+export declare interface PairingResponse {
+    result: "success";
+}
+
+export declare interface PollingResponseData {
+    transactionId: string;
+    transactionTimeStamp: string;
+    merchantId: string;
+    deviceId: string;
+    transactionStatus: TransactionStatus;
+    data?: TransactionData;
+}
+
+export declare const PROD_SMARTPAY_API_URL = "https://api.smart-connect.cloud/POS";
+
+export declare enum ResultType {
+    Ok = "OK",
+    Cancelled = "CANCELLED",
+    DelayedTransaction = "DELAYED-TRANSACTION",
+    Failed = "FAILED",
+    FailedInterface = "FAILED-INTERFACE"
+}
+
+export declare class SmartPay {
+    private api;
+    constructor();
+    private getPairingParams;
+    sendPairingRequest(pairingCode: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    createTransaction(amount: number, transactionType: TransactionTypes): Promise<string>;
+    pollForOutcome(pollingUrl: string, delayed?: () => void): Promise<{
+        transactionOutcome: TransactionOutcome;
+        responseData: PollingResponseData;
+    }>;
+}
+
+declare interface TransactionData {
+    PosVendor: string;
+    PosRegisterID: string;
+    PosBusinessName: string;
+    AmountTotal: string;
+    DeviceID: string;
+    Function: string;
+    Merchant: string;
+    Company: string;
+    RequestId: string;
+    TransactionResult: TransactionResult;
+    Result: ResultType;
+    ResultText: string;
+    AuthId: string;
+    AcquirerRef: string;
+    TerminalRef: string;
+    CardPan: string;
+    CardType: string;
+    AccountType: string;
+    AmountSurcharge: string;
+    AmountTip: string;
+    Timestamp: string;
+    Receipt: string;
+    RequestTimestamp: string;
+    ResponseTimestamp: string;
+}
+
+export declare enum TransactionOutcome {
+    /**
+     * TransactionResult = "OK-ACCEPTED"
+     */
+    Accepted = 1,
+    /**
+     * TransactionResult = "OK-DECLINED"
+     */
+    Declined = 2,
+    /**
+     * TransactionResult = "CANCELLED", Result != "FAILED-INTERFACE"
+     */
+    Cancelled = 3,
+    /**
+     * TransactionResult = "CANCELLED", Result = "FAILED-INTERFACE"
+     */
+    DeviceOffline = 4,
+    /**
+     * Everything else
+     */
+    Failed = 5
+}
+
+export declare interface TransactionRequestParams {
+    POSRegisterID: string;
+    POSBusinessName: string;
+    POSVendorName: string;
+    TransactionMode: "ASYNC";
+    TransactionType: TransactionTypes;
+    AmountTotal: number;
+}
+
+export declare interface TransactionResponseData {
+    PollingUrl: string;
+}
+
+export declare enum TransactionResult {
+    OkAccepted = "OK-ACCEPTED",
+    OkDeclined = "OK-DECLINED",
+    OkDelayed = "OK-DELAYED",
+    Cancelled = "CANCELLED"
+}
+
+export declare enum TransactionStatus {
+    Completed = "COMPLETED",
+    Pending = "PENDING"
+}
+
+export declare enum TransactionTypes {
+    Purchase = "Card.Purchase",
+    Refund = "Card.Refund"
+}
+
+export declare const useSmartPay: () => {
+    pairTerminal: (pairingCode: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+};
+
+export { }

package/dist/smartpay.js

@@ -0,0 +1,205 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import axios, { HttpStatusCode, isAxiosError } from "axios";
+import { t as timeout } from "./index-C8vc_75e.js";
+import { c as checkPluginInitialized, e as environment, b as state } from "./state-0HFa2Xwz.js";
+import { Dialog } from "quasar";
+import { d as dialogDefaultOpts } from "./useLinkly-Cj-lTWld.js";
+var TransactionOutcome = /* @__PURE__ */ ((TransactionOutcome2) => {
+  TransactionOutcome2[TransactionOutcome2["Accepted"] = 1] = "Accepted";
+  TransactionOutcome2[TransactionOutcome2["Declined"] = 2] = "Declined";
+  TransactionOutcome2[TransactionOutcome2["Cancelled"] = 3] = "Cancelled";
+  TransactionOutcome2[TransactionOutcome2["DeviceOffline"] = 4] = "DeviceOffline";
+  TransactionOutcome2[TransactionOutcome2["Failed"] = 5] = "Failed";
+  return TransactionOutcome2;
+})(TransactionOutcome || {});
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["Completed"] = "COMPLETED";
+  TransactionStatus2["Pending"] = "PENDING";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+var TransactionResult = /* @__PURE__ */ ((TransactionResult2) => {
+  TransactionResult2["OkAccepted"] = "OK-ACCEPTED";
+  TransactionResult2["OkDeclined"] = "OK-DECLINED";
+  TransactionResult2["OkDelayed"] = "OK-DELAYED";
+  TransactionResult2["Cancelled"] = "CANCELLED";
+  return TransactionResult2;
+})(TransactionResult || {});
+var ResultType = /* @__PURE__ */ ((ResultType2) => {
+  ResultType2["Ok"] = "OK";
+  ResultType2["Cancelled"] = "CANCELLED";
+  ResultType2["DelayedTransaction"] = "DELAYED-TRANSACTION";
+  ResultType2["Failed"] = "FAILED";
+  ResultType2["FailedInterface"] = "FAILED-INTERFACE";
+  return ResultType2;
+})(ResultType || {});
+var TransactionTypes = /* @__PURE__ */ ((TransactionTypes2) => {
+  TransactionTypes2["Purchase"] = "Card.Purchase";
+  TransactionTypes2["Refund"] = "Card.Refund";
+  return TransactionTypes2;
+})(TransactionTypes || {});
+const DEV_SMARTPAY_API_URL = "https://api-dev.smart-connect.cloud/POS";
+const PROD_SMARTPAY_API_URL = "https://api.smart-connect.cloud/POS";
+class SmartConnectAPI {
+  constructor() {
+    __publicField(this, "api");
+    checkPluginInitialized();
+    this.api = axios.create({
+      baseURL: environment.value === "production" ? PROD_SMARTPAY_API_URL : DEV_SMARTPAY_API_URL,
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+      }
+    });
+  }
+  getPairingParams() {
+    return {
+      POSRegisterID: state.posRegisterId,
+      POSRegisterName: state.posRegisterName,
+      POSBusinessName: state.posBusinessName,
+      POSVendorName: state.productVendorName
+    };
+  }
+  async sendPairingRequest(pairingCode) {
+    var _a, _b;
+    try {
+      if (!pairingCode) {
+        return { success: false, message: "A pairing code has to be supplied." };
+      }
+      const pairingEndpoint = `/Pairing/${pairingCode}`;
+      const parameters = this.getPairingParams();
+      const res = await this.api.put(pairingEndpoint, null, { params: parameters });
+      return {
+        success: res.status === HttpStatusCode.Ok,
+        message: res.status === HttpStatusCode.Ok ? "Pairing complete! Your device should now show it is paired." : "Failed to pair terminal"
+      };
+    } catch (error) {
+      const errorMessage = isAxiosError(error) ? (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.error : error;
+      return {
+        success: false,
+        message: errorMessage
+      };
+    }
+  }
+  async createTransaction(amount, transactionType) {
+    var _a, _b;
+    if (!Number.isInteger(amount) || amount <= 0) {
+      throw new Error("The amount must be a positive integer.");
+    }
+    if (!transactionType) {
+      throw new Error("The transactionType must be supplied.");
+    }
+    const transactionEndpoint = "/Transaction";
+    const parameters = {
+      ...this.getPairingParams(),
+      TransactionMode: "ASYNC",
+      TransactionType: transactionType,
+      AmountTotal: amount
+    };
+    try {
+      const response = await this.api.post(
+        transactionEndpoint,
+        null,
+        { params: parameters }
+      );
+      if (response.status === HttpStatusCode.Ok && ((_b = (_a = response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.PollingUrl)) {
+        return response.data.data.PollingUrl;
+      } else {
+        throw new Error("Invalid response or missing Polling URL");
+      }
+    } catch (error) {
+      console.error("Transaction creation failed:", error);
+      throw error;
+    }
+  }
+  async pollForOutcome(pollingUrl, delayed) {
+    if (!pollingUrl) {
+      throw new Error("Polling URL must be provided");
+    }
+    const MAX_INTERVAL_TIME = 10 * 60 * 1e3;
+    const endTime = Date.now() + MAX_INTERVAL_TIME;
+    const poll = async () => {
+      var _a;
+      console.log("Polling for outcome:", pollingUrl);
+      try {
+        const response = await this.api.get(pollingUrl);
+        console.log("Polling response:", response.data);
+        if (response.status === HttpStatusCode.Ok && ((_a = response.data) == null ? void 0 : _a.data)) {
+          const transactionStatus = response.data.transactionStatus;
+          const transactionResult = response.data.data.TransactionResult;
+          const result = response.data.data.Result;
+          if (transactionStatus === TransactionStatus.Completed) {
+            let transactionOutcome;
+            if (transactionResult === TransactionResult.OkAccepted) {
+              transactionOutcome = TransactionOutcome.Accepted;
+            } else if (transactionResult === TransactionResult.OkDeclined) {
+              transactionOutcome = TransactionOutcome.Declined;
+            } else if (transactionResult === TransactionResult.Cancelled && result !== ResultType.FailedInterface) {
+              transactionOutcome = TransactionOutcome.Cancelled;
+            } else if (transactionResult === TransactionResult.Cancelled && result === ResultType.FailedInterface) {
+              transactionOutcome = TransactionOutcome.DeviceOffline;
+            } else {
+              transactionOutcome = TransactionOutcome.Failed;
+            }
+            return { transactionOutcome, responseData: response.data };
+          } else if (transactionStatus === TransactionStatus.Pending && transactionResult === TransactionResult.OkDelayed && delayed) {
+            delayed();
+          }
+        }
+        if (Date.now() < endTime) {
+          await timeout();
+          return poll();
+        } else {
+          throw new Error("Polling timed out");
+        }
+      } catch (error) {
+        console.error("Polling request failed:", error);
+        if (Date.now() < endTime) {
+          await timeout();
+          return poll();
+        } else {
+          throw new Error("Polling timed out");
+        }
+      }
+    };
+    return poll();
+  }
+}
+const useSmartPay = () => {
+  const smartPayApi = new SmartConnectAPI();
+  const pairTerminal = async (pairingCode) => {
+    const dialog = Dialog.create({ ...dialogDefaultOpts, message: "Pairing with the terminal" });
+    try {
+      const res = await smartPayApi.sendPairingRequest(pairingCode);
+      dialog.update({
+        title: res.success ? "Success!" : "Failed!",
+        class: res.success ? "text-green-500" : "text-red-500",
+        message: "Pairing complete! Your device should now show it is paired.",
+        progress: false
+      });
+      return res;
+    } catch (error) {
+      dialog.update({
+        title: "Failed!",
+        class: "text-red-500",
+        progress: false,
+        message: `Error! Message: ${error}`
+      });
+      return { success: false, message: `Error! Message: ${error}` };
+    } finally {
+      setTimeout(dialog.hide, 2500);
+    }
+  };
+  return { pairTerminal };
+};
+export {
+  DEV_SMARTPAY_API_URL,
+  PROD_SMARTPAY_API_URL,
+  ResultType,
+  SmartConnectAPI as SmartPay,
+  TransactionOutcome,
+  TransactionResult,
+  TransactionStatus,
+  TransactionTypes,
+  useSmartPay
+};

package/dist/state-0HFa2Xwz.js

@@ -0,0 +1,36 @@
+import { reactive, ref } from "vue";
+const state = reactive({
+  productName: "",
+  productVersion: "",
+  productVendorName: "",
+  posId: "",
+  posRegisterId: "",
+  posRegisterName: "",
+  posBusinessName: "",
+  tyroApiKey: ""
+});
+const environment = ref("production");
+const isPluginInitialized = ref(false);
+const setState = (options) => {
+  options.productName && (state.productName = options.productName);
+  options.productVersion && (state.productVersion = options.productVersion);
+  options.productVendorName && (state.productVendorName = options.productVendorName);
+  options.posId && (state.posId = options.posId);
+  options.posRegisterId && (state.posRegisterId = options.posRegisterId);
+  options.posRegisterName && (state.posRegisterName = options.posRegisterName);
+  options.posBusinessName && (state.posBusinessName = options.posBusinessName);
+  options.tyroApiKey && (state.tyroApiKey = options.tyroApiKey);
+};
+const setEnvironment = (env) => environment.value = env;
+const checkPluginInitialized = () => {
+  if (isPluginInitialized.value) return true;
+  throw new Error("[Vue Payment Gateway] Plugin is not initialized.");
+};
+export {
+  setEnvironment as a,
+  state as b,
+  checkPluginInitialized as c,
+  environment as e,
+  isPluginInitialized as i,
+  setState as s
+};

package/dist/tyro.d.ts

@@ -0,0 +1,147 @@
+export declare const DEV_TYRO_IFRAME_URL = "https://iclientsimulator.test.tyro.com/logs.html#";
+
+export declare const DEV_TYRO_SDK_URL = "https://iclientsimulator.test.tyro.com/iclient-with-ui-v1.js";
+
+export declare interface PairResponse {
+    /**
+     * Status of the pairing request, can be inProgress, success, failure. If inProgress then more responses will follow.
+     */
+    status: "success" | "inProgress" | "failure";
+    /**
+     * The Text message to display to the merchant
+     */
+    message: string;
+    /**
+     * The integration key that is returned, and is to be used to authenticate when transacting.
+     */
+    integrationKey: string;
+}
+
+export declare type PairTyroCallback = (response: PairResponse) => void;
+
+export declare const PROD_TYRO_IFRAME_URL = "https://iclient.tyro.com/logs.html#";
+
+export declare const PROD_TYRO_SDK_URL = "https://iclient.tyro.com/iclient-with-ui-v1.js";
+
+export declare interface PurchaseRequestParams {
+    /**
+     * Indicate whether receipts will be printed on the POS (true) or on the terminal (false).
+     */
+    integratedReceipt: boolean;
+    /**
+     * Apply a surcharge to this transaction (if the card used attracts a surcharge).
+     */
+    enableSurcharge?: boolean;
+    /**
+     * The purchase amount (amount to charge the customer) in cents.
+     */
+    amount: string;
+    /**
+     * Cash out amount in cents.
+     */
+    cashout?: string;
+    /**
+     * Supply a transaction Id to be used for the transaction.
+     */
+    transactionId?: string;
+}
+
+export declare type ReceiptCallback = (response: ReceiptResponse) => void;
+
+export declare interface ReceiptResponse {
+    /**
+     * Indicates whether a signature line should be printed and a customer signature collected.
+     */
+    signatureRequired: boolean;
+    /**
+     * Text representation of the Tyro receipt intended for the merchant. Formatted to be printed in a monospaced font.
+     */
+    merchantReceipt: string;
+}
+
+export declare interface RefundRequestParams {
+    /**
+     * Indicate whether receipts will be printed on the POS (true) or on the terminal (false).
+     */
+    integratedReceipt: boolean;
+    /**
+     * The refund amount in cents.
+     */
+    amount: string;
+    /**
+     * Supply a transaction Id to be used for the transaction.
+     */
+    transactionId?: string;
+}
+
+export declare interface TransactionCallbacks {
+    /**
+     * Invoked when integrated receipts are enabled and a merchant copy of the receipt is available.
+     * Ignored if integrated receipt printing is disabled. Called with the following parameters as part of the receipt object.
+     * @param response
+     * @returns
+     */
+    receiptCallback: ReceiptCallback;
+    /**
+     * Invoked when the transaction has been completed on the terminal.
+     * Called with a subset of the following parameters as part of the transactionData object.
+     * for more info visit https://docs.integrated-eftpos.tyro.com/integrated-eftpos/iclient/implementation-guide/purchase-cashout-refund/callback/
+     * @param response
+     * @returns
+     */
+    transactionCompleteCallback: (response: TransactionCompleteResponse) => void;
+}
+
+export declare interface TransactionCompleteResponse {
+    /**
+     * The applied surcharge amount for the given transaction.
+     */
+    surchargeAmount: string;
+    /**
+     * Text representation of the Tyro receipt intended for the customer.
+     * Only included if integrated receipt printing is enabled. Formatted to be printed in a monospaced font.
+     */
+    customerReceipt: string;
+    /**
+     * The scheme displayed on the card (Visa, Mastercard, etc).
+     */
+    cardType: string;
+    result: TyroTransactionStatus;
+}
+
+export declare interface TyroPosProductInfo {
+    /**
+     * Name of your company.
+     */
+    posProductVendor: string;
+    /**
+     * Name of your product.
+     */
+    posProductName: string;
+    /**
+     * Version of your product.
+     */
+    posProductVersion: string;
+    /**
+     * customer ID or address
+     */
+    siteReference: string;
+}
+
+export declare enum TyroTransactionStatus {
+    APPROVED = "APPROVED",
+    CANCELLED = "CANCELLED",
+    REVERSED = "REVERSED",
+    DECLINED = "DECLINED",
+    NOT_STARTED = "NOT STARTED",
+    SYSTEM_ERROR = "SYSTEM ERROR",
+    UNKNOWN = "UNKNOWN"
+}
+
+export declare const useTyro: () => {
+    pairTyro: (merchantId: string, terminalId: string) => Promise<PairResponse>;
+    initiateTyroPurchase: (requestParams: PurchaseRequestParams, receiptCallback: ReceiptCallback) => Promise<TransactionCompleteResponse>;
+    initiateTyroRefund: (requestParams: RefundRequestParams, receiptCallback: ReceiptCallback) => Promise<TransactionCompleteResponse>;
+};
+
+export { }

package/dist/tyro.js

@@ -0,0 +1,111 @@
+import { QSpinnerHourglass, Dialog } from "quasar";
+import { c as checkPluginInitialized, b as state } from "./state-0HFa2Xwz.js";
+const dialogDefaultOpts = {
+  message: "Pairing in progress...",
+  class: "text-lg",
+  progress: {
+    // spinner: QSpinnerClock,
+    spinner: QSpinnerHourglass,
+    color: "amber"
+  },
+  persistent: true,
+  html: true,
+  ok: false,
+  cancel: {
+    label: "Close",
+    noCaps: true,
+    color: "red",
+    outline: true
+  }
+};
+const responseReceivedCallbackImp = (dialog, response) => {
+  console.log(response);
+  if (response.status === "inProgress") {
+    dialog == null ? void 0 : dialog.update({ message: response.message });
+    return;
+  }
+  if (response.status === "success") {
+    dialog == null ? void 0 : dialog.update({
+      title: "Success!",
+      class: "text-green-500",
+      progress: false,
+      message: `<div class="text-gray-800 text-base">${response.message}</div>`
+    });
+    setTimeout(() => {
+      dialog == null ? void 0 : dialog.hide();
+    }, 4500);
+    return;
+  }
+  dialog == null ? void 0 : dialog.update({
+    title: "Failed!",
+    class: "text-red-500",
+    progress: false,
+    message: `<div class="text-gray-800 text-base">${response.message}</div>`
+  });
+};
+const useTyro = () => {
+  checkPluginInitialized();
+  const iclient = new TYRO.IClientWithUI(state.tyroApiKey, {
+    posProductVendor: state.productVendorName,
+    posProductName: state.productName,
+    posProductVersion: state.productVersion,
+    siteReference: ""
+  });
+  const pairTyro = (merchantId, terminalId) => {
+    return new Promise((resolve, _reject) => {
+      const dialog = Dialog.create({ ...dialogDefaultOpts });
+      if (!merchantId || !terminalId) {
+        responseReceivedCallbackImp(dialog, {
+          message: "merchantId and terminalId is required to pair tyro.",
+          status: "failure",
+          integrationKey: ""
+        });
+        resolve({
+          message: "merchantId and terminalId is required to pair tyro.",
+          status: "failure",
+          integrationKey: ""
+        });
+        return;
+      }
+      iclient.pairTerminal(merchantId, terminalId, (res) => {
+        responseReceivedCallbackImp(dialog, res);
+        if (res.status !== "inProgress") {
+          resolve(res);
+        }
+      });
+    });
+  };
+  const initiateTyroPurchase = (requestParams, receiptCallback) => {
+    return new Promise((resolve, _reject) => {
+      iclient.initiatePurchase(requestParams, { transactionCompleteCallback: resolve, receiptCallback });
+    });
+  };
+  const initiateTyroRefund = (requestParams, receiptCallback) => {
+    return new Promise((resolve, _reject) => {
+      iclient.initiateRefund(requestParams, { transactionCompleteCallback: resolve, receiptCallback });
+    });
+  };
+  return { pairTyro, initiateTyroPurchase, initiateTyroRefund };
+};
+const DEV_TYRO_IFRAME_URL = "https://iclientsimulator.test.tyro.com/logs.html#";
+const DEV_TYRO_SDK_URL = "https://iclientsimulator.test.tyro.com/iclient-with-ui-v1.js";
+const PROD_TYRO_IFRAME_URL = "https://iclient.tyro.com/logs.html#";
+const PROD_TYRO_SDK_URL = "https://iclient.tyro.com/iclient-with-ui-v1.js";
+var TyroTransactionStatus = /* @__PURE__ */ ((TyroTransactionStatus2) => {
+  TyroTransactionStatus2["APPROVED"] = "APPROVED";
+  TyroTransactionStatus2["CANCELLED"] = "CANCELLED";
+  TyroTransactionStatus2["REVERSED"] = "REVERSED";
+  TyroTransactionStatus2["DECLINED"] = "DECLINED";
+  TyroTransactionStatus2["NOT_STARTED"] = "NOT STARTED";
+  TyroTransactionStatus2["SYSTEM_ERROR"] = "SYSTEM ERROR";
+  TyroTransactionStatus2["UNKNOWN"] = "UNKNOWN";
+  return TyroTransactionStatus2;
+})(TyroTransactionStatus || {});
+export {
+  DEV_TYRO_IFRAME_URL,
+  DEV_TYRO_SDK_URL,
+  PROD_TYRO_IFRAME_URL,
+  PROD_TYRO_SDK_URL,
+  TyroTransactionStatus,
+  useTyro
+};