@signal24/vue-foundation 4.14.0 → 4.15.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@signal24/vue-foundation",
     "type": "module",
-    "version": "4.14.0",
+    "version": "4.15.0",
     "description": "Common components, directives, and helpers for Vue 3 apps",
     "module": "./dist/vue-foundation.es.js",
     "exports": {

package/src/components/alert-helpers.ts

@@ -1,23 +1,37 @@
 import AlertModal from './alert-modal.vue';
 import { createOverlayInjection, presentOverlay, removeOverlayInjection } from './overlay-container';
 
-function resolveAlertParams(titleOrMessage: string | Error, message?: string | Error) {
-    const title = message ? (titleOrMessage as string) : undefined;
-    const resolvedMessage = message ?? titleOrMessage;
-    return { title, message: resolvedMessage };
+interface IAlertOptions {
+    title?: string;
+    message: string | Error;
+    classes?: string[];
+}
+
+function resolveAlertParams(arg0: string | Error | IAlertOptions, arg1?: string | Error) {
+    if (typeof arg0 === 'object' && !(arg0 instanceof Error)) {
+        return {
+            ...arg0,
+            classes: arg0.classes ?? []
+        };
+    }
+    const title = arg1 ? (arg0 as string) : undefined;
+    return { title, message: arg1 ?? arg0, classes: [] };
 }
 
 export async function showAlert(title: string, message: string | Error): Promise<void>;
 export async function showAlert(message: string | Error): Promise<void>;
-export async function showAlert(titleOrMessage: string | Error, message?: string | Error): Promise<void> {
-    await presentOverlay(AlertModal, resolveAlertParams(titleOrMessage, message));
+export async function showAlert(options: IAlertOptions): Promise<void>;
+export async function showAlert(arg0: string | Error | IAlertOptions, arg1?: string | Error): Promise<void> {
+    await presentOverlay(AlertModal, resolveAlertParams(arg0, arg1));
 }
 
 export async function showConfirm(title: string, message: string): Promise<boolean>;
 export async function showConfirm(message: string): Promise<boolean>;
-export async function showConfirm(titleOrMessage: string, message?: string): Promise<boolean> {
+export async function showConfirm(options: IAlertOptions): Promise<boolean>;
+export async function showConfirm(arg0: string | IAlertOptions, arg1?: string): Promise<boolean> {
+    const params = resolveAlertParams(arg0, arg1);
     const result = await presentOverlay(AlertModal, {
-        ...resolveAlertParams(titleOrMessage, message),
+        ...params,
         shouldConfirm: true
     });
     return result === true;
@@ -25,22 +39,26 @@ export async function showConfirm(titleOrMessage: string, message?: string): Pro
 
 export async function showConfirmDestroy(title: string, message: string): Promise<boolean>;
 export async function showConfirmDestroy(message: string): Promise<boolean>;
-export async function showConfirmDestroy(titleOrMessage: string, message?: string): Promise<boolean> {
+export async function showConfirmDestroy(options: IAlertOptions): Promise<boolean>;
+export async function showConfirmDestroy(arg0: string | IAlertOptions, arg1?: string): Promise<boolean> {
+    const params = resolveAlertParams(arg0, arg1);
     const result = await presentOverlay(AlertModal, {
-        ...resolveAlertParams(titleOrMessage, message),
+        ...params,
         shouldConfirm: true,
-        classes: ['destructive']
+        classes: ['destructive', ...params.classes]
     });
     return result === true;
 }
 
 export function showWait(title: string, message: string): () => void;
 export function showWait(message: string): () => void;
-export function showWait(titleOrMessage: string, message?: string): () => void {
+export function showWait(options: IAlertOptions): () => void;
+export function showWait(arg0: string | IAlertOptions, arg1?: string): () => void {
+    const params = resolveAlertParams(arg0, arg1);
     const injection = createOverlayInjection(AlertModal, {
-        ...resolveAlertParams(titleOrMessage, message),
+        ...params,
         isBare: true,
-        classes: ['wait'],
+        classes: ['wait', ...params.classes],
         callback: () => {}
     });
     return () => removeOverlayInjection(injection);

package/src/components/overlay-container.ts

@@ -63,9 +63,8 @@ export type Vue__ComponentPublicInstanceConstructor<
     new (...args: any[]): T;
 };
 
-export type ObjectComponentConfig<T extends Vue__ComponentPublicInstanceConstructor> = T extends Vue__ComponentPublicInstanceConstructor<infer P>
-    ? P
-    : never;
+export type ObjectComponentConfig<T extends Vue__ComponentPublicInstanceConstructor> =
+    T extends Vue__ComponentPublicInstanceConstructor<infer P> ? P : never;
 export type ObjectComponentProps<T extends Vue__ComponentPublicInstanceConstructor> = Writable<
     Omit<ObjectComponentConfig<T>['$props'], keyof VNodeProps | keyof AllowedComponentProps>
 >;

package/src/helpers/error.ts

@@ -21,14 +21,22 @@ export function toError(err: any) {
     return err instanceof Error ? err : new Error(String(err));
 }
 
-export async function handleErrorAndAlert(errIn: any, alertTitle?: string) {
+interface IErrorAlertOptions {
+    title?: string;
+    classes?: string[];
+}
+export async function handleErrorAndAlert(errIn: any, options?: IErrorAlertOptions) {
     const err = toError(errIn);
 
     if (!(err instanceof UserError)) {
         VfOptions.errorHandler(err);
     }
 
-    return alertTitle ? showAlert(alertTitle, err) : showAlert(err);
+    return showAlert({
+        title: options?.title,
+        message: err,
+        classes: options?.classes
+    });
 }
 
 export async function handleError(errIn: any) {