@shopfront/bridge 1.10.0 → 1.11.0

package/lib/Bridge.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -143,7 +147,7 @@ class Bridge {
         }
     }
     removeEventListener(listener) {
-        let index = this.listeners.indexOf(listener);
+        const index = this.listeners.indexOf(listener);
         if (index === -1) {
             return;
         }

package/lib/Common/EventEmitter.d.ts

@@ -1,7 +1,8 @@
+import { MaybePromise } from "../Utilities/MiscTypes";
 export declare class EventEmitter {
     protected supportedEvents: Array<string>;
     private listeners;
-    addEventListener(event: string, callback: Function): void;
-    removeEventListener(event: string, callback: Function): void;
-    protected emit(event: string, ...args: any[]): Promise<Array<any>>;
+    addEventListener(event: string, callback: (...args: Array<unknown>) => MaybePromise<unknown>): void;
+    removeEventListener(event: string, callback: (...args: Array<unknown>) => MaybePromise<unknown>): void;
+    protected emit(event: string, ...args: Array<unknown>): Promise<Array<unknown>>;
 }

package/lib/Common/Serializable.d.ts

@@ -1,5 +1,5 @@
 export interface Serialized<T> {
-    properties: Array<any>;
+    properties: Array<unknown>;
     events: {
         [event: string]: Array<string>;
     };

package/lib/EmitableEvents/SellScreenPromotionApplicable.d.ts

@@ -0,0 +1,13 @@
+import { BaseEmitableEvent } from "./BaseEmitableEvent";
+export interface PromotionApplicableData {
+    enable: boolean;
+    key: string;
+}
+export declare class SellScreenPromotionApplicable extends BaseEmitableEvent<PromotionApplicableData> {
+    /**
+     * Enable or disable a set of already created "applicable" promotions
+     * @param key {string} The key to enable or disable, this supports wildcards using an asterisk
+     * @param enable {boolean} Whether the key should be enabled or disabled
+     */
+    constructor(key: string, enable: boolean);
+}

package/lib/EmitableEvents/SellScreenPromotionApplicable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SellScreenPromotionApplicable = void 0;
+const BaseEmitableEvent_1 = require("./BaseEmitableEvent");
+const ApplicationEvents_1 = require("../ApplicationEvents");
+class SellScreenPromotionApplicable extends BaseEmitableEvent_1.BaseEmitableEvent {
+    /**
+     * Enable or disable a set of already created "applicable" promotions
+     * @param key {string} The key to enable or disable, this supports wildcards using an asterisk
+     * @param enable {boolean} Whether the key should be enabled or disabled
+     */
+    constructor(key, enable) {
+        super(ApplicationEvents_1.ToShopfront.SELL_SCREEN_PROMOTION_APPLICABLE, {
+            key,
+            enable,
+        });
+    }
+}
+exports.SellScreenPromotionApplicable = SellScreenPromotionApplicable;

package/lib/Events/BaseEvent.d.ts

@@ -1,5 +1,6 @@
-export declare abstract class BaseEvent {
-    protected callback: Function;
-    protected constructor(callback: Function);
-    abstract emit(data: object): Promise<any>;
+import { Bridge } from "../Bridge";
+export declare abstract class BaseEvent<TData = any, TCallbackReturn = void, TEmitReturn = any, TCallbackData = TData, TCallbackContext = undefined> {
+    protected callback: (data: TCallbackData, context: TCallbackContext) => TCallbackReturn;
+    protected constructor(callback: (data: TCallbackData, context: TCallbackContext) => TCallbackReturn);
+    abstract emit(data: TData, bridge?: Bridge): Promise<TEmitReturn>;
 }

package/lib/Events/BaseEvent.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEvent = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class BaseEvent {
     constructor(callback) {
         this.callback = callback;

package/lib/Events/Callback.d.ts

@@ -2,5 +2,5 @@ import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEven
 import { BaseEvent } from "./BaseEvent";
 export declare class Callback extends BaseEvent {
     constructor(callback: FromShopfrontCallbacks["CALLBACK"]);
-    emit(data: {}): Promise<FromShopfrontReturns["CALLBACK"]>;
+    emit(): Promise<FromShopfrontReturns["CALLBACK"]>;
 }

package/lib/Events/Callback.js

@@ -6,8 +6,8 @@ class Callback extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        return this.callback();
+    async emit() {
+        return this.callback(undefined, undefined);
     }
 }
 exports.Callback = Callback;

package/lib/Events/FormatIntegratedProduct.d.ts

@@ -1,6 +1,7 @@
 import { BaseEvent } from "./BaseEvent";
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export declare type FormattedSaleProductType = "Normal" | "Product" | "GiftCard" | "Voucher" | "Basket" | "Package" | "Component" | "Integrated";
 export interface SaleGiftCard {
     code: string;
@@ -60,13 +61,23 @@ export interface FormattedSaleProduct {
     requestPrice?: boolean;
     lockQuantity: boolean;
     metaData: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
-export declare class FormatIntegratedProduct extends BaseEvent {
+export declare class FormatIntegratedProduct extends BaseEvent<{
+    data: {
+        product: FormattedSaleProduct;
+    };
+    context: Record<string, never>;
+}, MaybePromise<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>, FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"], {
+    product: FormattedSaleProduct;
+}, Record<string, never>> {
     constructor(callback: FromShopfrontCallbacks["FORMAT_INTEGRATED_PRODUCT"]);
     emit(data: {
-        product: FormattedSaleProduct;
+        data: {
+            product: FormattedSaleProduct;
+        };
+        context: Record<string, never>;
     }): Promise<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>;
     static respond(bridge: Bridge, data: Array<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>, id: string): Promise<void>;
 }

package/lib/Events/FormatIntegratedProduct.js

@@ -8,7 +8,7 @@ class FormatIntegratedProduct extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        const result = await Promise.resolve(this.callback(data));
+        const result = await this.callback(data.data, data.context);
         if (typeof result !== "object" || result === null) {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/InternalPageMessage.d.ts

@@ -1,14 +1,10 @@
 import { BaseEvent } from "./BaseEvent";
-import { FromShopfront, FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
+import { FromShopfront, FromShopfrontCallbacks, FromShopfrontReturns, InternalPageMessageEvent } from "../ApplicationEvents";
 import { InternalMessageSource } from "../APIs/InternalMessages/InternalMessageSource";
 import { Application } from "../Application";
-export declare class InternalPageMessage extends BaseEvent {
+export declare class InternalPageMessage extends BaseEvent<InternalPageMessageEvent> {
     protected application: Application;
     constructor(callback: FromShopfrontCallbacks["INTERNAL_PAGE_MESSAGE"], application: Application);
-    protected createReference(method: keyof FromShopfront, url: string): InternalMessageSource;
-    emit(data: {
-        method: keyof FromShopfront;
-        url: string;
-        message: any;
-    }): Promise<FromShopfrontReturns["INTERNAL_PAGE_MESSAGE"]>;
+    protected createReference(method: keyof FromShopfront | "EXTERNAL_APPLICATION", url: string): InternalMessageSource;
+    emit(data: InternalPageMessageEvent): Promise<FromShopfrontReturns["INTERNAL_PAGE_MESSAGE"]>;
 }

package/lib/Events/InternalPageMessage.js

@@ -17,7 +17,7 @@ class InternalPageMessage extends BaseEvent_1.BaseEvent {
             url: data.url,
             message: data.message,
             reference: this.createReference(data.method, data.url)
-        });
+        }, undefined);
     }
 }
 exports.InternalPageMessage = InternalPageMessage;

package/lib/Events/PaymentMethodsEnabled.d.ts

@@ -0,0 +1,15 @@
+import { BaseEvent } from "./BaseEvent";
+import { FromShopfrontCallbacks, FromShopfrontReturns, PaymentMethodEnabledContext, SellScreenPaymentMethod } from "../ApplicationEvents";
+import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class PaymentMethodsEnabled extends BaseEvent<{
+    data: Array<SellScreenPaymentMethod>;
+    context: PaymentMethodEnabledContext;
+}, MaybePromise<FromShopfrontReturns["PAYMENT_METHODS_ENABLED"]>, FromShopfrontReturns["PAYMENT_METHODS_ENABLED"], Array<SellScreenPaymentMethod>, PaymentMethodEnabledContext> {
+    constructor(callback: FromShopfrontCallbacks["PAYMENT_METHODS_ENABLED"]);
+    emit(data: {
+        data: Array<SellScreenPaymentMethod>;
+        context: PaymentMethodEnabledContext;
+    }): Promise<FromShopfrontReturns["PAYMENT_METHODS_ENABLED"]>;
+    static respond(bridge: Bridge, data: FromShopfrontReturns["PAYMENT_METHODS_ENABLED"], id: string): Promise<void>;
+}

package/lib/Events/PaymentMethodsEnabled.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodsEnabled = void 0;
+const BaseEvent_1 = require("./BaseEvent");
+const ApplicationEvents_1 = require("../ApplicationEvents");
+class PaymentMethodsEnabled extends BaseEvent_1.BaseEvent {
+    constructor(callback) {
+        super(callback);
+    }
+    async emit(data) {
+        const result = await this.callback(data.data, data.context);
+        if (typeof result !== "object" || result === null) {
+            throw new TypeError("Callback must return an object");
+        }
+        return result;
+    }
+    static async respond(bridge, data, id) {
+        bridge.sendMessage(ApplicationEvents_1.ToShopfront.RESPONSE_UI_PIPELINE, data, id);
+    }
+}
+exports.PaymentMethodsEnabled = PaymentMethodsEnabled;

package/lib/Events/Ready.d.ts

@@ -1,6 +1,6 @@
-import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
+import { FromShopfrontCallbacks, FromShopfrontReturns, RegisterChangedEvent } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
-export declare class Ready extends BaseEvent {
+export declare class Ready extends BaseEvent<RegisterChangedEvent> {
     constructor(callback: FromShopfrontCallbacks["READY"]);
     emit(data: {
         outlet: string | null;

package/lib/Events/Ready.js

@@ -11,7 +11,7 @@ class Ready extends BaseEvent_1.BaseEvent {
             outlet: data.outlet,
             register: data.register,
             user: data.user,
-        });
+        }, undefined);
     }
 }
 exports.Ready = Ready;

package/lib/Events/RegisterChanged.js

@@ -7,7 +7,7 @@ class RegisterChanged extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        this.callback(data);
+        this.callback(data, undefined);
     }
 }
 exports.RegisterChanged = RegisterChanged;

package/lib/Events/RequestButtons.d.ts

@@ -1,12 +1,17 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge, Button } from "..";
 import { BaseEvent } from "./BaseEvent";
-export declare class RequestButtons extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestButtons extends BaseEvent<{
+    location: string;
+    id: string;
+    context: unknown;
+}, MaybePromise<FromShopfrontReturns["REQUEST_BUTTONS"]>, MaybePromise<FromShopfrontReturns["REQUEST_BUTTONS"]>, string, unknown> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_BUTTONS"]);
     emit(data: {
         location: string;
         id: string;
-        context: any;
+        context: unknown;
     }): Promise<FromShopfrontReturns["REQUEST_BUTTONS"]>;
     static respond(bridge: Bridge, buttons: Array<Button>, id: string): Promise<void>;
 }

package/lib/Events/RequestButtons.js

@@ -9,7 +9,7 @@ class RequestButtons extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        let result = await Promise.resolve(this.callback(data.location, data.context));
+        let result = await this.callback(data.location, data.context);
         if (!Array.isArray(result)) {
             result = [result];
         }
@@ -21,7 +21,7 @@ class RequestButtons extends BaseEvent_1.BaseEvent {
         return result;
     }
     static async respond(bridge, buttons, id) {
-        let response = [];
+        const response = [];
         for (let i = 0, l = buttons.length; i < l; i++) {
             if (!(buttons[i] instanceof __1.Button)) {
                 throw new TypeError("Invalid response returned, expected button");

package/lib/Events/RequestCustomerListOptions.d.ts

@@ -1,12 +1,13 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export interface SellScreenCustomerListOption {
     contents: string;
     onClick: () => void;
 }
-export declare class RequestCustomerListOptions extends BaseEvent {
+export declare class RequestCustomerListOptions extends BaseEvent<Record<string, unknown>, MaybePromise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>, FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"], undefined> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_CUSTOMER_LIST_OPTIONS"]);
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>;
+    emit(_: Record<string, unknown>): Promise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>;
     static respond(bridge: Bridge, options: Array<SellScreenCustomerListOption>, id: string): Promise<void>;
 }

package/lib/Events/RequestCustomerListOptions.js

@@ -8,8 +8,9 @@ class RequestCustomerListOptions extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        let result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }

package/lib/Events/RequestSaleKeys.d.ts

@@ -2,7 +2,8 @@ import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEven
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
 import { SaleKey } from "../Actions/SaleKey";
-export declare class RequestSaleKeys extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestSaleKeys extends BaseEvent<undefined, MaybePromise<Array<SaleKey>>, Array<SaleKey>> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SALE_KEYS"]);
     emit(): Promise<FromShopfrontReturns["REQUEST_SALE_KEYS"]>;
     static respond(bridge: Bridge, keys: Array<SaleKey>, id: string): Promise<void>;

package/lib/Events/RequestSaleKeys.js

@@ -9,7 +9,7 @@ class RequestSaleKeys extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit() {
-        let result = await Promise.resolve(this.callback());
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }
@@ -21,7 +21,7 @@ class RequestSaleKeys extends BaseEvent_1.BaseEvent {
         return result;
     }
     static async respond(bridge, keys, id) {
-        let response = [];
+        const response = [];
         for (let i = 0, l = keys.length; i < l; i++) {
             if (!(keys[i] instanceof SaleKey_1.SaleKey)) {
                 throw new TypeError("Invalid response returned, expected SaleKey");

package/lib/Events/RequestSellScreenOptions.d.ts

@@ -1,15 +1,16 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export interface SellScreenOption {
     url: string;
     title: string;
     id?: string;
 }
-export declare class RequestSellScreenOptions extends BaseEvent {
+export declare class RequestSellScreenOptions extends BaseEvent<undefined, MaybePromise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>, FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SELL_SCREEN_OPTIONS"]);
     static getOptionId(url: string): string;
     static validateURL(url: string): void;
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>;
+    emit(_: never): Promise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>;
     static respond(bridge: Bridge, options: Array<SellScreenOption>, id: string): Promise<void>;
 }

package/lib/Events/RequestSellScreenOptions.js

@@ -22,8 +22,9 @@ class RequestSellScreenOptions extends BaseEvent_1.BaseEvent {
             throw new TypeError(`The URL "${url}" is invalid, please ensure that you're using the HTTPS protocol`);
         }
     }
-    async emit(data) {
-        let result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }

package/lib/Events/RequestSettings.d.ts

@@ -1,8 +1,9 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
 import { Bridge } from "../Bridge";
-export declare class RequestSettings extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestSettings extends BaseEvent<undefined, MaybePromise<FromShopfrontReturns["REQUEST_SETTINGS"]>, FromShopfrontReturns["REQUEST_SETTINGS"]> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SETTINGS"]);
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_SETTINGS"]>;
+    emit(_: never): Promise<FromShopfrontReturns["REQUEST_SETTINGS"]>;
     static respond(bridge: Bridge, settings: Array<FromShopfrontReturns["REQUEST_SETTINGS"]>, id: string): Promise<void>;
 }

package/lib/Events/RequestSettings.js

@@ -7,8 +7,9 @@ class RequestSettings extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        const result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        const result = await this.callback(undefined, undefined);
         if (typeof result !== "object" || result === null) {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/RequestTableColumns.d.ts

@@ -1,11 +1,15 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
 import { Bridge } from "../Bridge";
-export declare class RequestTableColumns extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestTableColumns extends BaseEvent<{
+    location: string;
+    context: unknown;
+}, MaybePromise<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>, FromShopfrontReturns["REQUEST_TABLE_COLUMNS"], string, unknown> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_TABLE_COLUMNS"]);
     emit(data: {
         location: string;
-        context: any;
+        context: unknown;
     }): Promise<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>;
     static respond(bridge: Bridge, columns: Array<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>, id: string): Promise<void>;
 }

package/lib/Events/RequestTableColumns.js

@@ -8,7 +8,7 @@ class RequestTableColumns extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        const result = await Promise.resolve(this.callback(data.location, data.context));
+        const result = await this.callback(data.location, data.context);
         if (typeof result !== "object") {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/SaleComplete.d.ts

@@ -57,7 +57,7 @@ interface CompletedSaleProduct {
     requestPrice?: boolean;
     lockQuantity: boolean;
     metaData: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 interface CompletedSalePayment {

package/lib/Events/SaleComplete.js

@@ -7,7 +7,7 @@ class SaleComplete extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        this.callback(data);
+        this.callback(data, undefined);
     }
 }
 exports.SaleComplete = SaleComplete;

package/lib/Events/UIPipeline.d.ts

@@ -0,0 +1,15 @@
+import { BaseEvent } from "./BaseEvent";
+import { FromShopfrontCallbacks, FromShopfrontReturns, UIPipelineBaseContext, UIPipelineContext, UIPipelineResponse } from "../ApplicationEvents";
+import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
+interface UIPPipelineIncomingData {
+    data: Array<UIPipelineResponse>;
+    context: UIPipelineBaseContext;
+    pipelineId?: string;
+}
+export declare class UIPipeline extends BaseEvent<UIPPipelineIncomingData, MaybePromise<FromShopfrontReturns["UI_PIPELINE"]>, FromShopfrontReturns["UI_PIPELINE"], Array<UIPipelineResponse>, UIPipelineContext> {
+    constructor(callback: FromShopfrontCallbacks["UI_PIPELINE"]);
+    emit(data: UIPPipelineIncomingData, bridge: Bridge): Promise<FromShopfrontReturns["UI_PIPELINE"]>;
+    static respond(bridge: Bridge, data: FromShopfrontReturns["UI_PIPELINE"], id: string): Promise<void>;
+}
+export {};

package/lib/Events/UIPipeline.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIPipeline = void 0;
+const BaseEvent_1 = require("./BaseEvent");
+const ApplicationEvents_1 = require("../ApplicationEvents");
+class UIPipeline extends BaseEvent_1.BaseEvent {
+    constructor(callback) {
+        super(callback);
+    }
+    async emit(data, bridge) {
+        const context = {
+            ...data.context
+        };
+        if (typeof data.pipelineId === "string") {
+            context.trigger = () => {
+                bridge.sendMessage(ApplicationEvents_1.ToShopfront.PIPELINE_TRIGGER, {
+                    id: data.pipelineId,
+                });
+            };
+        }
+        const result = await this.callback(data.data, context);
+        if (typeof result !== "object" || result === null) {
+            throw new TypeError("Callback must return an object");
+        }
+        return result;
+    }
+    static async respond(bridge, data, id) {
+        bridge.sendMessage(ApplicationEvents_1.ToShopfront.RESPONSE_UI_PIPELINE, data, id);
+    }
+}
+exports.UIPipeline = UIPipeline;

package/lib/Utilities/ActionEventRegistrar.d.ts

@@ -1,12 +1,12 @@
 import { BaseAction } from "../Actions/BaseAction";
 declare class ActionEventRegistrar {
     events: {
-        [id: string]: BaseAction<any>;
+        [id: string]: BaseAction<undefined>;
     };
     constructor();
-    add(id: string, action: BaseAction<any>): void;
+    add(id: string, action: BaseAction<undefined>): void;
     remove(id: string): void;
-    fire(id: string, data: any): void;
+    fire(id: string, data: unknown): void;
     clear(): void;
 }
 declare const _default: ActionEventRegistrar;

package/lib/Utilities/MiscTypes.d.ts

@@ -2,3 +2,6 @@
  * A property which might be a promise or the promise's wrapped type
  */
 export declare type MaybePromise<P> = P | Promise<P>;
+export interface ConstructorClass<T> {
+    new (...args: Array<unknown>): T;
+}

package/lib/Utilities/Static.js

@@ -1,7 +1,9 @@
 "use strict";
+// noinspection JSUnusedLocalSymbols
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.staticImplements = void 0;
 function staticImplements() {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/no-unused-vars
     return (constructor) => { };
 }
 exports.staticImplements = staticImplements;

package/lib/index.d.ts

@@ -1,11 +1,12 @@
 export { Bridge } from "./Bridge";
 export { Button } from "./Actions/Button";
 export { Redirect } from "./Actions/Redirect";
-export { Toast } from "./Actions/Toast";
+export { Toast, ToastType } from "./Actions/Toast";
 export { Dialog } from "./Actions/Dialog";
 export { SaleKey } from "./Actions/SaleKey";
 export { SellScreenOption } from "./EmitableEvents/SellScreenOption";
 export { TableUpdate } from "./EmitableEvents/TableUpdate";
+export { SellScreenPromotionApplicable } from "./EmitableEvents/SellScreenPromotionApplicable";
 export { CompletedSale } from "./Events/SaleComplete";
 export { Application } from "./Application";
 export * as Sales from "./APIs/CurrentSale/index";

package/lib/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sales = exports.Application = exports.TableUpdate = exports.SellScreenOption = exports.SaleKey = exports.Dialog = exports.Toast = exports.Redirect = exports.Button = exports.Bridge = void 0;
+exports.Sales = exports.Application = exports.SellScreenPromotionApplicable = exports.TableUpdate = exports.SellScreenOption = exports.SaleKey = exports.Dialog = exports.Toast = exports.Redirect = exports.Button = exports.Bridge = void 0;
 var Bridge_1 = require("./Bridge");
 Object.defineProperty(exports, "Bridge", { enumerable: true, get: function () { return Bridge_1.Bridge; } });
 var Button_1 = require("./Actions/Button");
@@ -36,6 +40,8 @@ var SellScreenOption_1 = require("./EmitableEvents/SellScreenOption");
 Object.defineProperty(exports, "SellScreenOption", { enumerable: true, get: function () { return SellScreenOption_1.SellScreenOption; } });
 var TableUpdate_1 = require("./EmitableEvents/TableUpdate");
 Object.defineProperty(exports, "TableUpdate", { enumerable: true, get: function () { return TableUpdate_1.TableUpdate; } });
+var SellScreenPromotionApplicable_1 = require("./EmitableEvents/SellScreenPromotionApplicable");
+Object.defineProperty(exports, "SellScreenPromotionApplicable", { enumerable: true, get: function () { return SellScreenPromotionApplicable_1.SellScreenPromotionApplicable; } });
 var Application_1 = require("./Application");
 Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return Application_1.Application; } });
 exports.Sales = __importStar(require("./APIs/CurrentSale/index"));