@shopfront/bridge 2.0.0 → 2.0.1

package/lib/Mocks/MockApplication.d.ts

@@ -0,0 +1,154 @@
+import { Sale } from "../APIs/Sale/index.js";
+import { DirectShopfrontEvent, DirectShopfrontEventCallback, FromShopfront, FromShopfrontCallbacks, FromShopfrontInternal, ListenableFromShopfrontEvents, RegisterChangedEvent, SellScreenActionMode, SellScreenSummaryMode, SoundEvents } from "../ApplicationEvents.js";
+import { BaseApplication, ShopfrontEmbeddedVerificationToken } from "../BaseApplication.js";
+import { Serializable } from "../Common/Serializable.js";
+import { BaseEmitableEvent } from "../EmitableEvents/BaseEmitableEvent.js";
+import { MaybePromise } from "../Utilities/MiscTypes.js";
+import { MockCurrentSale } from "./APIs/Sale/MockCurrentSale.js";
+import { MockBridge } from "./MockBridge.js";
+interface AudioRequestOptions {
+    hasPermission: boolean;
+    forceError: boolean;
+}
+export declare class MockApplication extends BaseApplication {
+    protected currentSale: MockCurrentSale | false;
+    constructor(bridge: MockBridge);
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * Handles an application event
+     */
+    protected handleEvent: (event: keyof FromShopfront | keyof FromShopfrontInternal, data: Record<string, unknown>, id: string) => void;
+    /**
+     * Calls any registered listeners for the received event
+     */
+    protected emit(event: ListenableFromShopfrontEvents | DirectShopfrontEvent, data: (Record<string, unknown> | string) | undefined, id: string): MaybePromise<void>;
+    /**
+     * @inheritDoc
+     */
+    addEventListener<E extends ListenableFromShopfrontEvents>(event: E, callback: FromShopfrontCallbacks[E]): void;
+    /**
+     * @inheritDoc
+     */
+    addEventListener(event: DirectShopfrontEvent, callback: DirectShopfrontEventCallback): void;
+    /**
+     * @inheritDoc
+     */
+    removeEventListener<E extends keyof FromShopfrontCallbacks>(event: E, callback: FromShopfrontCallbacks[E]): void;
+    /**
+     * @inheritDoc
+     */
+    removeEventListener<D>(event: DirectShopfrontEvent, callback: (event: D) => MaybePromise<void>): void;
+    /**
+     * @inheritDoc
+     */
+    send(item: BaseEmitableEvent<unknown> | Serializable<unknown>): void;
+    /**
+     * @inheritDoc
+     */
+    download(file: string): void;
+    /**
+     * @inheritDoc
+     */
+    redirect(toLocation: string, externalRedirect?: boolean): void;
+    /**
+     * @inheritDoc
+     */
+    load(): () => void;
+    /**
+     * @inheritDoc
+     */
+    protected handleEventCallback(data: {
+        id?: string;
+        data: unknown;
+    }): void;
+    /**
+     * Updates the cached location data
+     */
+    protected handleLocationChanged: (data: RegisterChangedEvent) => undefined;
+    /**
+     * @inheritDoc
+     */
+    getAuthenticationKey(): string;
+    /**
+     * @inheritDoc
+     */
+    getCurrentSale(): Promise<MockCurrentSale | false>;
+    /**
+     * @inheritDoc
+     */
+    createSale(sale: Sale): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    getLocation(options?: {
+        globalMode: boolean;
+        useRegister: boolean;
+    }): Promise<{
+        register: string | null;
+        outlet: string | null;
+        user: string | null;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    printReceipt(content: string): void;
+    /**
+     * @inheritDoc
+     */
+    changeSellScreenActionMode(mode: SellScreenActionMode): void;
+    /**
+     * @inheritDoc
+     */
+    changeSellScreenSummaryMode(mode: SellScreenSummaryMode): void;
+    /**
+     * @inheritDoc
+     */
+    protected sendAudioRequest(type: SoundEvents, data?: unknown, options?: AudioRequestOptions): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    requestAudioPermission(options?: AudioRequestOptions): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    audioPreload(url: string, options?: AudioRequestOptions): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    audioPlay(url: string, options?: AudioRequestOptions): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    getOption<TValueType>(option: string, defaultValue: TValueType): Promise<TValueType>;
+    /**
+     * @inheritDoc
+     */
+    getToken(returnTokenObject: true): Promise<ShopfrontEmbeddedVerificationToken>;
+    /**
+     * @inheritDoc
+     */
+    getToken(returnTokenObject?: false): Promise<string>;
+    /**
+     * Mocks an event being fired from Shopfront
+     */
+    fireEvent<T extends ListenableFromShopfrontEvents, HasParams extends (Parameters<FromShopfront[T]["emit"]> extends [never] ? false : true)>(event: T | DirectShopfrontEvent, ...data: HasParams extends true ? Parameters<FromShopfront[T]["emit"]> : [undefined]): void;
+}
+export {};

package/lib/Mocks/MockApplication.js

@@ -0,0 +1,482 @@
+import { isDirectShopfrontEvent, ToShopfront, } from "../ApplicationEvents.js";
+import { BaseApplication } from "../BaseApplication.js";
+import { AudioPermissionChange } from "../Events/AudioPermissionChange.js";
+import { AudioReady } from "../Events/AudioReady.js";
+import { FormatIntegratedProduct } from "../Events/FormatIntegratedProduct.js";
+import { FulfilmentCollectOrder } from "../Events/FulfilmentCollectOrder.js";
+import { FulfilmentCompleteOrder } from "../Events/FulfilmentCompleteOrder.js";
+import { FulfilmentGetOrder } from "../Events/FulfilmentGetOrder.js";
+import { FulfilmentOrderApproval } from "../Events/FulfilmentOrderApproval.js";
+import { FulfilmentProcessOrder } from "../Events/FulfilmentProcessOrder.js";
+import { FulfilmentVoidOrder } from "../Events/FulfilmentVoidOrder.js";
+import { GiftCardCodeCheck } from "../Events/GiftCardCodeCheck.js";
+import { InternalPageMessage } from "../Events/InternalPageMessage.js";
+import { PaymentMethodsEnabled } from "../Events/PaymentMethodsEnabled.js";
+import { Ready } from "../Events/Ready.js";
+import { RegisterChanged } from "../Events/RegisterChanged.js";
+import { RequestButtons } from "../Events/RequestButtons.js";
+import { RequestCustomerListOptions } from "../Events/RequestCustomerListOptions.js";
+import { RequestSaleKeys } from "../Events/RequestSaleKeys.js";
+import { RequestSellScreenOptions } from "../Events/RequestSellScreenOptions.js";
+import { RequestSettings } from "../Events/RequestSettings.js";
+import { RequestTableColumns } from "../Events/RequestTableColumns.js";
+import { SaleComplete } from "../Events/SaleComplete.js";
+import { UIPipeline } from "../Events/UIPipeline.js";
+import ActionEventRegistrar from "../Utilities/ActionEventRegistrar.js";
+import { MockCurrentSale } from "./APIs/Sale/MockCurrentSale.js";
+import { MockDatabase } from "./Database/MockDatabase.js";
+export class MockApplication extends BaseApplication {
+    constructor(bridge) {
+        super(bridge, new MockDatabase(bridge));
+        this.currentSale = false;
+        /**
+         * Handles an application event
+         */
+        this.handleEvent = (event, data, id) => {
+            if (event === "READY") {
+                this.isReady = true;
+                this.key = data.key;
+                this.outlet = data.outlet;
+                this.register = data.register;
+                data = {
+                    outlet: data.outlet,
+                    register: data.register,
+                };
+            }
+            if (event === "CALLBACK") {
+                // Actions aren't implemented
+                return;
+            }
+            if (event === "CYCLE_KEY") {
+                // Not needed
+                return;
+            }
+            else if (event === "LOCATION_CHANGED") {
+                // Unregister all serialized listeners as they're no longer displayed
+                ActionEventRegistrar.clear();
+                return;
+            }
+            else if (event === "RESPONSE_CURRENT_SALE" ||
+                event === "RESPONSE_DATABASE_REQUEST" ||
+                event === "RESPONSE_LOCATION" ||
+                event === "RESPONSE_OPTION" ||
+                event === "RESPONSE_AUDIO_REQUEST" ||
+                event === "RESPONSE_SECURE_KEY" ||
+                event === "RESPONSE_CREATE_SALE") {
+                // Handled elsewhere
+                return;
+            }
+            this.emit(event, data, id);
+        };
+        /**
+         * Updates the cached location data
+         */
+        this.handleLocationChanged = (data) => {
+            this.register = data.register;
+            this.outlet = data.outlet;
+            this.user = data.user;
+        };
+        this.bridge.addEventListener(this.handleEvent);
+        this.addEventListener("REGISTER_CHANGED", this.handleLocationChanged);
+        this.fireEvent.bind(this);
+        // Fire a ready event immediately
+        this.handleEvent("READY", {
+            key: "embedded-key",
+            outlet: "outlet-id",
+            register: "register-id",
+        }, "");
+    }
+    /**
+     * @inheritDoc
+     */
+    destroy() {
+        this.bridge.destroy();
+    }
+    /**
+     * Calls any registered listeners for the received event
+     */
+    emit(event, data = {}, id) {
+        if (isDirectShopfrontEvent(event)) {
+            const listeners = this.directListeners[event];
+            if (typeof listeners === "undefined") {
+                // Don't need to do anything here
+                return;
+            }
+            const results = [];
+            for (const e of listeners.values()) {
+                results.push(e());
+            }
+            return Promise.all(results)
+                .then(() => {
+                // Ensure void is returned
+            });
+        }
+        const results = [];
+        if (typeof this.listeners[event] === "undefined") {
+            // Don't need to do anything here
+            return;
+        }
+        if (this.listeners[event].size === 0) {
+            // Don't need to do anything here
+            return;
+        }
+        const bridge = this.bridge;
+        for (const e of this.listeners[event].values()) {
+            results.push(e.emit(data, bridge));
+        }
+        // The responses have been removed as we don't currently need them
+    }
+    /**
+     * @inheritDoc
+     */
+    addEventListener(event, callback) {
+        if (isDirectShopfrontEvent(event)) {
+            if (typeof this.directListeners[event] === "undefined") {
+                this.directListeners[event] = new Set();
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.directListeners[event].add(callback);
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let c;
+        switch (event) {
+            case "READY":
+                c = new Ready(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_SETTINGS":
+                c = new RequestSettings(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_BUTTONS":
+                c = new RequestButtons(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_TABLE_COLUMNS":
+                c = new RequestTableColumns(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_SELL_SCREEN_OPTIONS":
+                c = new RequestSellScreenOptions(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "INTERNAL_PAGE_MESSAGE":
+                c = new InternalPageMessage(callback, this);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REGISTER_CHANGED":
+                c = new RegisterChanged(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_CUSTOMER_LIST_OPTIONS":
+                c = new RequestCustomerListOptions(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FORMAT_INTEGRATED_PRODUCT":
+                c = new FormatIntegratedProduct(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "REQUEST_SALE_KEYS":
+                c = new RequestSaleKeys(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "SALE_COMPLETE":
+                c = new SaleComplete(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "UI_PIPELINE":
+                c = new UIPipeline(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "PAYMENT_METHODS_ENABLED":
+                c = new PaymentMethodsEnabled(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "AUDIO_READY":
+                c = new AudioReady(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "AUDIO_PERMISSION_CHANGE":
+                c = new AudioPermissionChange(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_GET_ORDER":
+                if (this.listeners[event].size !== 0) {
+                    throw new TypeError("Application already has 'FULFILMENT_GET_ORDER' event listener registered.");
+                }
+                c = new FulfilmentGetOrder(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_VOID_ORDER":
+                c = new FulfilmentVoidOrder(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_PROCESS_ORDER":
+                c = new FulfilmentProcessOrder(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_ORDER_APPROVAL":
+                c = new FulfilmentOrderApproval(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_ORDER_COLLECTED":
+                c = new FulfilmentCollectOrder(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "FULFILMENT_ORDER_COMPLETED":
+                c = new FulfilmentCompleteOrder(callback);
+                this.listeners[event].set(callback, c);
+                break;
+            case "GIFT_CARD_CODE_CHECK":
+                c = new GiftCardCodeCheck(callback);
+                this.listeners[event].set(callback, c);
+                break;
+        }
+        if (typeof c === "undefined") {
+            throw new TypeError(`${event} has not been defined`);
+        }
+        if (event === "READY" && this.isReady) {
+            c = c;
+            c.emit({
+                outlet: this.outlet,
+                register: this.register,
+                user: this.user,
+            });
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    removeEventListener(event, callback) {
+        if (isDirectShopfrontEvent(event)) {
+            this.directListeners[event]?.delete(callback);
+            return;
+        }
+        this.listeners[event].delete(callback);
+    }
+    /**
+     * @inheritDoc
+     */
+    send(item) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    download(file) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    redirect(toLocation, externalRedirect = true) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    load() {
+        return () => undefined;
+    }
+    /**
+     * @inheritDoc
+     */
+    handleEventCallback(data) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    getAuthenticationKey() {
+        return this.key;
+    }
+    /**
+     * @inheritDoc
+     */
+    async getCurrentSale() {
+        if (!this.currentSale) {
+            this.currentSale = new MockCurrentSale(this);
+        }
+        return this.currentSale;
+    }
+    /**
+     * @inheritDoc
+     */
+    async createSale(sale) {
+        if (!sale.getRegister() && !this.register) {
+            return {
+                success: false,
+                message: "Sale has not provided a register and Shopfront currently doesn't have a register selected.",
+            };
+        }
+        if (!this.user) {
+            return {
+                success: false,
+                message: "A sale cannot be created when there is no user logged in to Shopfront.",
+            };
+        }
+        const payments = sale.getPayments();
+        let totalPaid = 0;
+        for (const payment of payments) {
+            // TODO: Double check this is still the case
+            if (payment.getCashout()) {
+                return {
+                    success: false,
+                    message: "Sale payment with cash out is currently unsupported " +
+                        "through the Embedded Fulfilment API.",
+                };
+            }
+            if (payment.getRounding()) {
+                return {
+                    success: false,
+                    message: "Sale payment with rounding is currently unsupported " +
+                        "through the Embedded Fulfilment API.",
+                };
+            }
+            totalPaid += payment.getAmount();
+        }
+        // Round to 4 decimal places to keep consistent with POS
+        const remaining = Math.round((sale.getSaleTotal() - totalPaid) * 1000) / 1000;
+        if (remaining < 0) {
+            return {
+                success: false,
+                message: "Total paid is greater than sale total.",
+            };
+        }
+        return {
+            success: true,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    async getLocation(options) {
+        if (options) {
+            if (options.globalMode) {
+                return {
+                    register: null,
+                    outlet: null,
+                    user: "shopfront-user-id",
+                };
+            }
+            else if (!options.useRegister) {
+                return {
+                    register: null,
+                    outlet: "shopfront-outlet-id",
+                    user: "shopfront-user-id",
+                };
+            }
+        }
+        return {
+            register: "shopfront-register-id",
+            outlet: "shopfront-outlet-id",
+            user: "shopfront-user-id",
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    printReceipt(content) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    changeSellScreenActionMode(mode) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    changeSellScreenSummaryMode(mode) {
+        /* empty */
+    }
+    /**
+     * @inheritDoc
+     */
+    async sendAudioRequest(type, data, options) {
+        if (options) {
+            if (!options.hasPermission) {
+                return {
+                    success: false,
+                    message: "You do not have permission to play audio",
+                };
+            }
+            if (options.forceError) {
+                return {
+                    success: false,
+                    message: "An error occurred whilst trying to play the audio",
+                };
+            }
+        }
+        return {
+            success: true,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    requestAudioPermission(options) {
+        return this.sendAudioRequest(ToShopfront.AUDIO_REQUEST_PERMISSION, undefined, options);
+    }
+    /**
+     * @inheritDoc
+     */
+    audioPreload(url, options) {
+        return this.sendAudioRequest(ToShopfront.AUDIO_PRELOAD, {
+            url,
+        }, options);
+    }
+    /**
+     * @inheritDoc
+     */
+    audioPlay(url, options) {
+        return this.sendAudioRequest(ToShopfront.AUDIO_PLAY, {
+            url,
+        }, options);
+    }
+    /**
+     * @inheritDoc
+     */
+    async getOption(option, defaultValue) {
+        return defaultValue;
+    }
+    /**
+     * @inheritDoc
+     */
+    async getToken(returnTokenObject) {
+        if (returnTokenObject) {
+            return {
+                id: "token-id",
+                app: "app-id",
+                auth: "embedded-token",
+                user: "user-id",
+                url: {
+                    raw: "https://testing.test",
+                    loaded: "https://frame.url",
+                },
+            };
+        }
+        return "embedded-token";
+    }
+    /**
+     * Mocks an event being fired from Shopfront
+     */
+    fireEvent(event, ...data) {
+        let params;
+        if (data.length > 0) {
+            if (typeof data[0] === "object") {
+                params = {
+                    ...data[0],
+                };
+            }
+            else {
+                params = data[0];
+            }
+            // We don't care about the Bridge parameter, as that is passed in by the `emit` method
+        }
+        this.emit(event, params, "");
+    }
+    ;
+}

package/lib/Mocks/MockBridge.d.ts

@@ -0,0 +1,31 @@
+import * as ApplicationEvents from "../ApplicationEvents.js";
+import { BaseBridge } from "../BaseBridge.js";
+import { ApplicationEventListener } from "../Bridge.js";
+export declare class MockBridge extends BaseBridge {
+    protected isReady: boolean;
+    constructor(key: string, url: string);
+    /**
+     * @inheritDoc
+     */
+    destroy(): void;
+    /**
+     * @inheritDoc
+     */
+    protected registerListeners(): void;
+    /**
+     * @inheritDoc
+     */
+    protected unregisterListeners(): void;
+    /**
+     * @inheritDoc
+     */
+    sendMessage(type: ApplicationEvents.ToShopfront, data?: unknown, id?: string): void;
+    /**
+     * @inheritDoc
+     */
+    addEventListener(listener: ApplicationEventListener): void;
+    /**
+     * @inheritDoc
+     */
+    removeEventListener(listener: ApplicationEventListener): void;
+}