fix(Application): Fix "notifyErrorAndThrow" not working with a short-…

…hand parameter

packages/Application/Dialog/DialogComponent.ts

@@ -13,14 +13,14 @@ export enum DialogConfirmationStrategy { Dialog, Tab, Window }
 
 export type PopupConfirmationStrategy = Exclude<DialogConfirmationStrategy, DialogConfirmationStrategy.Dialog>
 
+const dialogElementConstructorSymbol = Symbol('DialogComponent.DialogElementConstructor')
+
 export abstract class DialogComponent<T extends DialogParameters = void, TResult = void> extends Component {
 	static readonly connectingHooks = new HookSet<DialogComponent<any, any>>()
 
-	private static readonly dialogElementConstructorSymbol = Symbol('DialogComponent.DialogElementConstructor')
-
 	static dialogElement() {
 		return (constructor: Constructor<Dialog>) => {
-			(constructor as any)[DialogComponent.dialogElementConstructorSymbol] = true
+			(constructor as any)[dialogElementConstructorSymbol] = true
 		}
 	}
 
@@ -30,7 +30,7 @@ export abstract class DialogComponent<T extends DialogParameters = void, TResult
 		return Promise.resolve(Application.topLayer)
 	}
 
-	@querySymbolizedElement(DialogComponent.dialogElementConstructorSymbol) readonly dialogElement!: Dialog & HTMLElement
+	@querySymbolizedElement(dialogElementConstructorSymbol) readonly dialogElement!: Dialog & HTMLElement
 
 	get primaryActionElement() { return this.dialogElement.primaryActionElement }
 

packages/Application/Notification/NotificationComponent.test.ts

@@ -0,0 +1,97 @@
+import { ComponentTestFixture } from '@a11d/lit-testing'
+import { Notification, NotificationComponent, NotificationType } from './NotificationComponent.js'
+import { component } from '@a11d/lit'
+
+describe('NotificationComponent', () => {
+	@NotificationComponent.defaultComponent()
+	@component('test-notification')
+	class TestNotificationComponent extends NotificationComponent {
+		override notification!: Notification
+
+		override show() {
+			return Promise.resolve()
+		}
+	}
+
+	const fixture = new ComponentTestFixture(() => new TestNotificationComponent())
+	fixture
+
+	const all = [
+		{ method: 'notifyInfo', type: NotificationType.Info },
+		{ method: 'notifySuccess', type: NotificationType.Success },
+		{ method: 'notifyWarning', type: NotificationType.Warning },
+		{ method: 'notifyError', type: NotificationType.Error },
+	] as const
+
+	const action = { title: 'Test', handleClick: () => { } }
+
+	for (const { method, type } of all) {
+
+		it(`should proxy "${method}" with shortened parameters to "notify" with correct parameters`, async () => {
+			spyOn(TestNotificationComponent, 'notify').and.callThrough()
+
+			await TestNotificationComponent[method]('Test', action)
+
+			expect(TestNotificationComponent.notify).toHaveBeenCalledWith({
+				type,
+				message: 'Test',
+				actions: [action],
+			})
+		})
+
+		it(`should proxy "${method}" with full parameters to "notify" with correct parameters`, async () => {
+			spyOn(TestNotificationComponent, 'notify').and.callThrough()
+
+			await TestNotificationComponent[method]({
+				message: 'Test',
+				actions: [action],
+			})
+
+			expect(TestNotificationComponent.notify).toHaveBeenCalledWith({
+				type,
+				message: 'Test',
+				actions: [action],
+			})
+		})
+	}
+
+	describe('notifyAndThrowError', () => {
+		it('should throw and proxy on shorthand parameters with error', () => {
+			spyOn(TestNotificationComponent, 'notify').and.callThrough()
+			const error = new Error('Test')
+
+			expect(() => TestNotificationComponent.notifyAndThrowError(error, action)).toThrow(error)
+			expect(TestNotificationComponent.notify).toHaveBeenCalledWith({
+				type: NotificationType.Error,
+				message: 'Test',
+				actions: [action],
+			})
+		})
+
+		it('should throw and proxy on shorthand parameters with error-message', () => {
+			spyOn(TestNotificationComponent, 'notify').and.callThrough()
+			const errorMessage = 'Test'
+
+			expect(() => TestNotificationComponent.notifyAndThrowError(errorMessage, action)).toThrow(new Error(errorMessage))
+			expect(TestNotificationComponent.notify).toHaveBeenCalledWith({
+				type: NotificationType.Error,
+				message: errorMessage,
+				actions: [action],
+			})
+		})
+
+		it('should throw and proxy on shorthand parameters with notification parameters', () => {
+			spyOn(TestNotificationComponent, 'notify').and.callThrough()
+
+			expect(() => TestNotificationComponent.notifyAndThrowError({
+				message: 'Test',
+				actions: [action],
+			})).toThrow(new Error('Test'))
+			expect(TestNotificationComponent.notify).toHaveBeenCalledWith({
+				type: NotificationType.Error,
+				message: 'Test',
+				actions: [action],
+			})
+		})
+	})
+})

packages/Application/Notification/NotificationComponent.ts

@@ -1,6 +1,6 @@
-import { LitElement } from "@a11d/lit"
-import { Application } from "../Application.js"
-import { NonInertableComponent } from "@a11d/non-inertable-component"
+import { LitElement } from '@a11d/lit'
+import { Application } from '../Application.js'
+import { NonInertableComponent } from '@a11d/non-inertable-component'
 
 export enum NotificationType {
 	Info = 'info',
@@ -27,8 +27,9 @@ type NonTypedNotificationParameters =
 	| [message: string, ...actions: Array<NotificationAction>]
 
 type NonTypedNotificationWithErrorParameters =
-	| [notification: Partial<NonTypedNotification>]
-	| [message?: string, ...actions: Array<NotificationAction>]
+	| [notification: NonTypedNotification]
+	| [errorMessage: string, ...actions: Array<NotificationAction>]
+	| [error: Error, ...actions: Array<NotificationAction>]
 
 function normalizeNonTypedNotificationParameters(...parameters: NonTypedNotificationParameters) {
 	return typeof parameters[0] !== 'string' ? parameters[0] : {
@@ -48,28 +49,35 @@ export abstract class NotificationComponent extends NonInertableComponent {
 		}
 	}
 
-	static notifyInfo(...notification: NonTypedNotificationParameters) {
-		return this.notify({ type: NotificationType.Info, ...normalizeNonTypedNotificationParameters(...notification) })
+	static notifyInfo(...parameters: NonTypedNotificationParameters) {
+		return this.notify({ type: NotificationType.Info, ...normalizeNonTypedNotificationParameters(...parameters) })
 	}
 
-	static notifySuccess(...notification: NonTypedNotificationParameters) {
-		return this.notify({ type: NotificationType.Success, ...normalizeNonTypedNotificationParameters(...notification) })
+	static notifySuccess(...parameters: NonTypedNotificationParameters) {
+		return this.notify({ type: NotificationType.Success, ...normalizeNonTypedNotificationParameters(...parameters) })
 	}
 
-	static notifyWarning(...notification: NonTypedNotificationParameters) {
-		return this.notify({ type: NotificationType.Warning, ...normalizeNonTypedNotificationParameters(...notification) })
+	static notifyWarning(...parameters: NonTypedNotificationParameters) {
+		return this.notify({ type: NotificationType.Warning, ...normalizeNonTypedNotificationParameters(...parameters) })
 	}
 
-	static notifyError(...notification: NonTypedNotificationParameters) {
-		return this.notify({ type: NotificationType.Error, ...normalizeNonTypedNotificationParameters(...notification) })
+	static notifyError(...parameters: NonTypedNotificationParameters) {
+		return this.notify({ type: NotificationType.Error, ...normalizeNonTypedNotificationParameters(...parameters) })
 	}
 
-	static notifyAndThrowError<TError extends Error>(error: TError, ...notification: NonTypedNotificationWithErrorParameters) {
-		const normalizedNotification = notification.length === 0
-			? {} as NonTypedNotification
-			: normalizeNonTypedNotificationParameters(...notification as NonTypedNotificationParameters)
-		normalizedNotification.message ??= error.message
-		this.notifyError(normalizedNotification)
+	static notifyAndThrowError(...parameters: NonTypedNotificationWithErrorParameters) {
+		let error: Error
+		if (parameters[0] instanceof Error) {
+			error = parameters[0]
+			this.notifyError({ message: error.message, actions: parameters.slice(1) as Array<NotificationAction> })
+		} else if (typeof parameters[0] === 'string') {
+			error = new Error(parameters[0])
+			this.notifyError({ message: error.message, actions: parameters.slice(1) as Array<NotificationAction> })
+		} else {
+			const notification = parameters[0]
+			error = new Error(notification.message)
+			this.notifyError(notification)
+		}
 		throw error
 	}
 

packages/Application/Page/PageComponent.ts

@@ -6,16 +6,16 @@ export type PageParameters = void | Record<string, string | number | undefined>
 
 export enum PageNavigationStrategy { Page, Tab, Window }
 
+const pageElementConstructorSymbol = Symbol('PageComponent.PageElementConstructor')
+
 export abstract class PageComponent<T extends PageParameters = void> extends Component {
 	static readonly connectingHooks = new HookSet<PageComponent<any>>()
 
-	private static readonly pageElementConstructorSymbol = Symbol('PageComponent.PageElementConstructor')
-
 	static defaultPageElementTag = literal`lit-page`
 
 	static pageElement() {
 		return (constructor: Constructor<Page>) => {
-			(constructor as any)[PageComponent.pageElementConstructorSymbol] = true
+			(constructor as any)[pageElementConstructorSymbol] = true
 		}
 	}
 
@@ -32,7 +32,7 @@ export abstract class PageComponent<T extends PageParameters = void> extends Com
 		}
 	}
 
-	@querySymbolizedElement(PageComponent.pageElementConstructorSymbol) readonly pageElement!: Page & HTMLElement
+	@querySymbolizedElement(pageElementConstructorSymbol) readonly pageElement!: Page & HTMLElement
 
 	constructor(readonly parameters: T) {
 		super()

packages/Application/PwaHelper/ManifestProvider.ts

@@ -1,6 +1,7 @@
-import { Application, type Manifest } from '../index.js'
+import { Application } from '../Application.js'
+import type { Manifest } from './Manifest.js'
 
-Application.connectingHooks.add(async () => {
+Application?.connectingHooks.add(async () => {
 	// @ts-expect-error - This is declared as a constant property
 	globalThis.manifest = undefined
 	const manifestLink = globalThis.document.head.querySelector<HTMLLinkElement>('link[rel=manifest]')

packages/Application/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@a11d/lit-application",
-	"version": "0.1.9",
+	"version": "0.1.10",
 	"description": "Lit-based application shell.",
 	"repository": {
 		"type": "git",

scripts/test.mjs

@@ -26,7 +26,8 @@ globalThis.environment = 'test'
 ${getTestFiles('./packages').map(file => {
 	const relativePath = Path.relative('./dist', file)
 	return `import '${relativePath.replace(/\\/g, '/').replace(/\.ts$/, '')}'`
-}).join('\n')}`
+}).join('\n')}
+`
 FileSystem.writeFileSync('./dist/test.ts', testIndexFileContent)
 
 await esbuild.build({