@achyutlabsau/vue-payment-gateway 0.0.1

package/README.md

@@ -0,0 +1,141 @@
+# Vue Payment Gateway
+
+A Vue.js payment gateway library to handle payments with ease.
+
+## Installation
+
+To install the library, run the following command:
+
+```bash
+npm install @achyutlabsau/vue-payment-gateway
+```
+
+## Plugin Initialization
+
+To use the payment gateway, you need to initialize the plugin in your Vue app. Here’s an example of how to set it up:
+
+```javascript
+import VuePaymentGateway from "@achyutlabsau/vue-payment-gateway";
+
+app.use(VuePaymentGateway, {
+  productName: "Pratham Respos", // Name of your product
+  productVersion: "3.3.0", // Version of your product
+  productVendorName: "Achyutlabs", // Name of the product vendor
+  posId: "unique-pos-id", // Unique identifier for the POS system
+  posRegisterId: "pos-register-id", // Unique identifier for the POS register
+  posRegisterName: "register-name", // Name of the POS register
+  posBusinessName: "business name", // Name of the business using the POS system
+  tyroApiKey: "tyro-api-key", // API key for Tyro integration
+  environment: "development", // Set environment to 'development' or 'production'
+});
+```
+
+> **Note:** Replace the placeholder values with the actual details of your POS system, product, and Tyro API key.
+
+## Using the Payment Gateway
+
+This library supports multiple payment providers, such as Tyro, SmartPay, and Linkly. Here’s how to use them in your application.
+
+### Using Tyro
+
+To use the Tyro payment gateway, import and initialize it as shown below:
+
+```javascript
+import { useTyro } from "@achyutlabsau/vue-payment-gateway/tyro";
+
+const tyro = useTyro();
+
+// Example usage
+await tyro.processPayment(amount, options);
+```
+
+### Using SmartPay
+
+To use the SmartPay payment gateway, import and initialize it as shown below:
+
+```javascript
+import { useSmartPay } from "@achyutlabsau/vue-payment-gateway/smartpay";
+
+const smartPay = useSmartPay();
+
+// Example usage
+await smartPay.processPayment(amount, options);
+```
+
+### Using Linkly
+
+To use the Linkly payment gateway, import and initialize it as shown below:
+
+```javascript
+import { useLinkly } from "@achyutlabsau/vue-payment-gateway/linkly";
+
+const linkly = useLinkly();
+
+// Example usage
+await linkly.processPayment(amount, options);
+```
+
+## Payment Method API
+
+Each payment provider (Tyro, SmartPay, Linkly) provides methods to process payments. Here are some of the most commonly used methods:
+
+### `processPayment(amount: number, options?: object)`
+
+Processes a payment for the specified amount.
+
+**Parameters:**
+
+- `amount`: The amount to be charged.
+- `options`: (Optional) Additional options for the payment.
+
+### `cancelPayment()`
+
+Cancels an ongoing payment.
+
+### `getStatus()`
+
+Gets the status of the current payment transaction.
+
+> **Note:** The methods may differ slightly between Tyro, SmartPay, and Linkly. Refer to the official documentation of each payment provider for more details.
+
+## Environment Configuration
+
+The environment can be set to either `development` or `production`. Make sure to use `development` during testing and switch to `production` in a live environment to ensure security and proper tracking.
+
+```javascript
+app.use(VuePaymentGateway, {
+  ...
+  environment: "production", // Set to 'production' in a live environment
+});
+```
+
+## Example Usage
+
+Here’s a complete example of how you might use the payment gateway to process a payment with Tyro:
+
+```javascript
+import { useTyro } from "@achyutlabsau/vue-payment-gateway/tyro";
+
+const tyro = useTyro();
+
+async function handlePayment() {
+  try {
+    const paymentResult = await tyro.processPayment(100, { currency: "USD" });
+    console.log("Payment successful:", paymentResult);
+  } catch (error) {
+    console.error("Payment failed:", error);
+  }
+}
+```
+
+## Troubleshooting
+
+- **Environment Issues**: Make sure `environment` is set correctly (`development` or `production`).
+- **Invalid API Key**: Ensure the Tyro API key is valid and correctly set in the configuration.
+- **Payment Processing Issues**: Check if the payment provider's service is online and available.
+
+## Additional Resources
+
+For more details and usage examples, refer to the official documentation or support channels provided by [Achyutlabs](https://achyutlabs.com/).
+
+With this guide, you should be able to set up and use the Vue Payment Gateway efficiently to handle payments with Tyro, SmartPay, and Linkly integrations.

package/dist/index-C8vc_75e.js

@@ -0,0 +1,15 @@
+import axios from "axios";
+const generateTransactionId = () => {
+  const timestamp = Date.now().toString();
+  const randomComponent = Math.floor(1e3 + Math.random() * 9e3).toString();
+  return `${timestamp}${randomComponent}`.slice(0, 16);
+};
+const timeout = (interval = 2e3) => new Promise((resolve) => setTimeout(resolve, interval));
+const isServerError = (status) => status && Number(status) >= 500 && Number(status) <= 599;
+const isNetworkError = (error) => axios.isAxiosError(error) && error.code === "ERR_NETWORK";
+export {
+  isServerError as a,
+  generateTransactionId as g,
+  isNetworkError as i,
+  timeout as t
+};

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { App } from 'vue';
+
+declare const _default: {
+    install: (_app: App, options: InstallOptions) => void;
+};
+export default _default;
+
+/**
+ * Generates a numeric transaction ID with a maximum length of 16 characters.
+ * The ID is composed of the current timestamp and a 4-digit random component.
+ *
+ * @returns {string} A unique numeric transaction ID with a maximum length of 16 characters.
+ *
+ * @example
+ * const transactionId = generateTransactionId();
+ * console.log(transactionId); // Output: '1699418999123456'
+ */
+export declare const generateTransactionId: () => string;
+
+declare interface InstallOptions extends POSConfig {
+    environment?: "development" | "production";
+}
+
+declare interface POSConfig {
+    productName: string;
+    productVersion: string;
+    productVendorName: string;
+    posId: string;
+    posRegisterId: string;
+    posRegisterName: string;
+    posBusinessName: string;
+    tyroApiKey: string;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,12 @@
+import { s as setState, a as setEnvironment, i as isPluginInitialized } from "./state-0HFa2Xwz.js";
+import { g } from "./index-C8vc_75e.js";
+const install = (_app, options) => {
+  setState(options);
+  options.environment && setEnvironment(options.environment);
+  isPluginInitialized.value = true;
+};
+const VuePaymentGateway = { install };
+export {
+  VuePaymentGateway as default,
+  g as generateTransactionId
+};

package/dist/linkly.d.ts

@@ -0,0 +1,390 @@
+declare interface Basket {
+    id: string;
+    amt: number;
+    tax: number;
+    dis: number;
+    sur: number;
+    items: BasketItem[];
+}
+
+declare interface BasketItem {
+    id: string;
+    sku: string;
+    qty: number;
+    amt: number;
+    tax: number;
+    dis: number;
+    name: string;
+}
+
+declare type BooleanishString = "0" | "1";
+
+export declare enum CurrencyCodes {
+    AustralianDollar = "AUD"
+}
+
+export declare interface LinklyAuthPayload {
+    /**
+     * The secret returned from the cloud pairing process
+     */
+    secret: string;
+    /**
+     * The name of the POS requesting the token
+     */
+    posName: string;
+    /**
+     * The version of the POS requesting the token
+     */
+    posVersion: string;
+    /**
+     * A unique UUID v4 which identifies the POS instance. This value is generated by the POS as a part of the POS deployment settings.
+     * e.g. Two registers at the same merchant should supply two different PosId values
+     */
+    posId: string;
+    /**
+     * A unique UUID v4 which identifies the POS POS product. This value can be hard coded into the build of the POS.
+     * e.g. All merchants using the same POS product should supply the same posVendorId value
+     */
+    posVendorId: string;
+}
+
+export declare interface LinklyAuthResponse {
+    /**
+     * The token to user for authentication.
+     */
+    token: string;
+    /**
+     * The number of seconds until the token expires.
+     */
+    expirySeconds: number;
+}
+
+export declare interface LinklyReprintReceiptRequest {
+    Request: {
+        /**
+         * Two Digit Merchant Code. Defaults to "00" (EFTPOS)
+         */
+        Merchant?: "00" | "99" | string;
+        /**
+         * 	Indicates where the request is to be sent to. Defaults to "00" (EFTPOS)
+         */
+        Application?: "00" | string;
+        /**
+         * Indicates if the POS is to receive receipt events.
+         */
+        ReceiptAutoPrint: ReceiptAutoPrint;
+        /**
+         * Indicates whether Linkly should cut receipts. Defaults to '0' (DontCut)
+         */
+        CutReceipt?: BooleanishString;
+        /**
+         * Indicates whether the receipt should be returned or reprinted. Defaults to '2' (GetLast) '1' is Reprint
+         */
+        ReprintType?: "2";
+        /**
+         * The original txnRef of the transaction
+         */
+        OriginalTxnRef?: string;
+        PurchaseAnalysisData?: PurchaseAnalysisData;
+    };
+    Notification?: Notification_2;
+}
+
+/**
+ * this will be used but currently not using this
+ *
+ */
+export declare interface LinklyReprintReceiptResponse {
+    sessionId: string;
+    responseType: "reprintreceipt";
+    response: {
+        merchant: string;
+        receiptText: string[];
+        responseCode: string;
+        responseText: string;
+        success: boolean;
+    };
+}
+
+export declare interface LinklyTransactionResponse {
+    SessionId: string;
+    ResponseType: string;
+    Response: {
+        TxnType: TransactionTypes;
+        Merchant: string;
+        CardType: string;
+        CardName: string;
+        RRN: string;
+        DateSettlement: string;
+        AmtCash: number;
+        AmtPurchase: number;
+        AmtTip: number;
+        AuthCode: string;
+        TxnRef: string;
+        Pan: string;
+        DateExpiry: string;
+        Track2: string;
+        AccountType: string;
+        TxnFlags: {
+            Offline: BooleanishString;
+            ReceiptPrinted: BooleanishString;
+            CardEntry: string;
+            CommsMethod: string;
+            Currency: string;
+            PayPass: string;
+            UndefinedFlag6: string;
+            UndefinedFlag7: string;
+        };
+        BalanceReceived: boolean;
+        AvailableBalance: number;
+        ClearedFundsBalance: number;
+        Success: boolean;
+        ResponseCode: ResponseCodes | string;
+        ResponseText: string;
+        Date: string;
+        Catid: string;
+        Caid: string;
+        Stan: number;
+        PurchaseAnalysisData: {
+            RFN: string;
+            REF: string;
+            HRC: string;
+            HRT: string;
+        };
+    };
+}
+
+declare interface Notification_2 {
+    Uri: string;
+    AuthorizationHeader: string;
+}
+
+export declare type PinpadPairingResult = {
+    success: boolean;
+    secret: string;
+    message: string;
+};
+
+export declare interface PinpadPairPayload {
+    /**
+     * The Linkly Cloud username
+     */
+    username: string;
+    /**
+     * The Linkly Cloud password
+     */
+    password: string;
+    /**
+     * The pair code displayed on the PIN pad in "pairing" mode
+     */
+    pairCode: string;
+}
+
+export declare interface PinpadPairResponse {
+    /**
+     * The non-expiring secret the POS uses to request an auth token
+     */
+    secret: string;
+}
+
+declare interface PurchaseAnalysisData {
+    OPR: string;
+    AMT: string;
+    PCM: string;
+}
+
+export declare enum ReceiptAutoPrint {
+    /**
+     * Return all receipts to the POS in a receipt event. Only supported when async=true.
+     */
+    ReturnToPOS = "0",
+    /**
+     * Print all merchant/signature receipts from the PINpad printer, return all other receipts to the POS in the transaction/logon/settlement response.
+     */
+    MixedPrint = "7",
+    /**
+     * Print all receipts from the PINpad printer.
+     */
+    AllReceiptsFromPINPad = "9"
+}
+
+export declare enum ResponseCodes {
+    /**
+     * Transaction / function completed successfully
+     */
+    APPROVED = "00",
+    /**
+     * Transaction / function completed successfully
+     */
+    Approved = "08",
+    TXN_CANCELLED = "HD",
+    /**
+     * The customer account does not have sufficient funds for the transaction
+     */
+    INSUFFICIENT_FUND = "HB",
+    /**
+     * Unexpected Error
+     */
+    GENERAL_DECLINE = "99",
+    /**
+     * Pinpad is offline
+     */
+    PINPAD_OFFLINE = "PF"
+}
+
+export declare enum TransactionOutcome {
+    APPROVED = "APPROVED",
+    CANCELLED = "CANCELLED",
+    DECLINED = "DECLINED",
+    UNKNOWN = "UNKNOWN"
+}
+
+export declare type TransactionPayload = Pick<TransactionPostRequest, "AmtPurchase" | "ReceiptAutoPrint" | "CutReceipt">;
+
+/**
+ * View Documentation - https://www.linkly.com.au/apidoc/REST/#purchase
+ */
+export declare interface TransactionPostPayload {
+    Request: TransactionPostRequest;
+    Notification?: Notification_2;
+}
+
+export declare interface TransactionPostRequest {
+    Merchant: "00";
+    /**
+     * Indicated the type of transaction to perform
+     */
+    TxnType: TransactionTypes;
+    /**
+     * Left zero filled, amount of sale in cents.
+     */
+    AmtPurchase: number;
+    /**
+     * The reference number to attach to the transaction. This will appear on the receipt.
+     */
+    TxnRef: string;
+    /**
+     * Code to indicate requested currency. e.g. 'AUD'
+     */
+    CurrencyCode: CurrencyCodes;
+    /**
+     * Indicates whether Linkly should cut receipts. Defaults to '0' (Don't Cut)
+     */
+    CutReceipt?: BooleanishString;
+    /**
+     * Indicates if the POS is to receive receipt events.
+     */
+    ReceiptAutoPrint: ReceiptAutoPrint;
+    /**
+     * Instructs Linkly to perform a card payment
+     */
+    Application: "00";
+    PurchaseAnalysisData?: PurchaseAnalysisData;
+    Basket?: Basket;
+}
+
+export declare enum TransactionTypes {
+    Purchase = "P",
+    Refund = "R"
+}
+
+export declare const useLinkly: () => {
+    pairPinpad: (pairData: PinpadPairPayload) => Promise<PinpadPairingResult>;
+    initiatePurchase: (data: TransactionPayload) => Promise<{
+        result: TransactionOutcome;
+        data: {
+            TxnType: TransactionTypes;
+            Merchant: string;
+            CardType: string;
+            CardName: string;
+            RRN: string;
+            DateSettlement: string;
+            AmtCash: number;
+            AmtPurchase: number;
+            AmtTip: number;
+            AuthCode: string;
+            TxnRef: string;
+            Pan: string;
+            DateExpiry: string;
+            Track2: string;
+            AccountType: string;
+            TxnFlags: {
+                Offline: "0" | "1";
+                ReceiptPrinted: "0" | "1";
+                CardEntry: string;
+                CommsMethod: string;
+                Currency: string;
+                PayPass: string;
+                UndefinedFlag6: string;
+                UndefinedFlag7: string;
+            };
+            BalanceReceived: boolean;
+            AvailableBalance: number;
+            ClearedFundsBalance: number;
+            Success: boolean;
+            ResponseCode: ResponseCodes | string;
+            ResponseText: string;
+            Date: string;
+            Catid: string;
+            Caid: string;
+            Stan: number;
+            PurchaseAnalysisData: {
+                RFN: string;
+                REF: string;
+                HRC: string;
+                HRT: string;
+            };
+        };
+    }>;
+    initiateRefund: (data: TransactionPayload) => Promise<{
+        result: TransactionOutcome;
+        data: {
+            TxnType: TransactionTypes;
+            Merchant: string;
+            CardType: string;
+            CardName: string;
+            RRN: string;
+            DateSettlement: string;
+            AmtCash: number;
+            AmtPurchase: number;
+            AmtTip: number;
+            AuthCode: string;
+            TxnRef: string;
+            Pan: string;
+            DateExpiry: string;
+            Track2: string;
+            AccountType: string;
+            TxnFlags: {
+                Offline: "0" | "1";
+                ReceiptPrinted: "0" | "1";
+                CardEntry: string;
+                CommsMethod: string;
+                Currency: string;
+                PayPass: string;
+                UndefinedFlag6: string;
+                UndefinedFlag7: string;
+            };
+            BalanceReceived: boolean;
+            AvailableBalance: number;
+            ClearedFundsBalance: number;
+            Success: boolean;
+            ResponseCode: ResponseCodes | string;
+            ResponseText: string;
+            Date: string;
+            Catid: string;
+            Caid: string;
+            Stan: number;
+            PurchaseAnalysisData: {
+                RFN: string;
+                REF: string;
+                HRC: string;
+                HRT: string;
+            };
+        };
+    }>;
+    reprintReceipt: (txnRef?: string) => Promise<LinklyReprintReceiptResponse>;
+    getTransactionBySessionId: (transactionId: string) => Promise<LinklyTransactionResponse>;
+    getLastTransaction: () => Promise<LinklyTransactionResponse>;
+};
+
+export { }

package/dist/linkly.js

@@ -0,0 +1,9 @@
+import { C, R, b, T, a, u } from "./useLinkly-Cj-lTWld.js";
+export {
+  C as CurrencyCodes,
+  R as ReceiptAutoPrint,
+  b as ResponseCodes,
+  T as TransactionOutcome,
+  a as TransactionTypes,
+  u as useLinkly
+};