Changed most events in LiveEditPage.ts and LiveEditPageProxy.ts to extend IframeEvent, started updating InitializeLiveEditEvent.ts to serialize itself to message

Author: pmi

src/main/resources/assets/admin/common/js/event/AbstractEvent.ts

@@ -21,9 +21,9 @@ export abstract class AbstractEvent {
         return this.name;
     }
 
-    abstract fire(contextWindow: Window);
+    abstract fire(contextWindow?: Window);
 
-    static getEventBus(contextWindow: Window): AbstractEventBus<AbstractEvent> {
+    static getEventBus(contextWindow?: Window): AbstractEventBus<AbstractEvent> {
         throw new Error('Method not implemented.');
     };
 }

src/main/resources/assets/admin/common/js/event/AbstractEventBus.ts

@@ -1,19 +1,19 @@
 import {AbstractEvent} from './AbstractEvent';
 
-export interface HandlersMapEntry {
-    handler: (event: AbstractEvent) => void;
+export interface HandlersMapEntry<E extends AbstractEvent> {
+    handler: (event: E) => void;
     customHandler?: (e: CustomEvent) => void;
 }
 
 export abstract class AbstractEventBus<E extends AbstractEvent> {
-    protected handlersMap: Record<string, HandlersMapEntry[]> = {};
+    protected handlersMap: Record<string, HandlersMapEntry<E>[]> = {};
     protected contextWindow: Window;
 
     protected constructor(contextWindow: Window = window) {
         this.contextWindow = contextWindow;
     }
 
-    onEvent(eventName: string, handler: (event: E) => void): HandlersMapEntry {
+    onEvent(eventName: string, handler: (event: E) => void): HandlersMapEntry<E> {
         if (!this.handlersMap[eventName]) {
             this.handlersMap[eventName] = [];
         }
@@ -22,8 +22,8 @@ export abstract class AbstractEventBus<E extends AbstractEvent> {
         return entry;
     }
 
-    unEvent(eventName: string, handler?: (event: E) => void): HandlersMapEntry[] {
-        const removedEntries: HandlersMapEntry[] = [];
+    unEvent(eventName: string, handler?: (event: E) => void): HandlersMapEntry<E>[] {
+        const removedEntries: HandlersMapEntry<E>[] = [];
         if (handler) {
             this.handlersMap[eventName] = (this.handlersMap[eventName] || []).filter(
                 entry => {

src/main/resources/assets/admin/common/js/event/Event.ts

@@ -4,11 +4,11 @@ import {AbstractEvent} from './AbstractEvent';
 export class Event
     extends AbstractEvent {
 
-    fire(contextWindow: Window = window) {
+    fire(contextWindow?: Window) {
         EventBus.get(contextWindow).fireEvent(this);
     }
 
-    static getEventBus(contextWindow: Window): EventBus {
+    static getEventBus(contextWindow?: Window): EventBus {
         return EventBus.get(contextWindow);
     }
 }

src/main/resources/assets/admin/common/js/event/EventBus.ts

@@ -8,14 +8,15 @@ export class EventBus
 
     static get(contextWindow: Window = window): EventBus {
         if (!EventBus.instance) {
+            console.info(`Creating new EventBus instance by ${window.location.pathname} on ${contextWindow.location.pathname}`);
             EventBus.instance = new EventBus(contextWindow);
         } else if (EventBus.instance.contextWindow !== contextWindow) {
             throw new Error('EventBus instance already created with a different contextWindow');
         }
         return EventBus.instance;
     }
 
-    onEvent(eventName: string, handler: (event: Event) => void): HandlersMapEntry {
+    onEvent(eventName: string, handler: (event: Event) => void): HandlersMapEntry<Event> {
         const entry = super.onEvent(eventName, handler);
         entry.customHandler = (e: CustomEvent) => handler(e.detail);
         this.contextWindow.addEventListener(eventName, entry.customHandler);
@@ -24,7 +25,7 @@ export class EventBus
 
     unEvent(eventName: string, handler?: (event: Event) => void) {
         const entries = super.unEvent(eventName, handler);
-        entries.forEach((entry: HandlersMapEntry) => {
+        entries.forEach((entry: HandlersMapEntry<Event>) => {
             this.contextWindow.removeEventListener(eventName, entry.customHandler);
         });
         return entries;

src/main/resources/assets/admin/common/js/event/IframeEvent.ts

@@ -4,11 +4,19 @@ import {AbstractEvent} from './AbstractEvent';
 export class IframeEvent
     extends AbstractEvent {
 
-    fire(contextWindow: Window = window) {
-        IframeEventBus.get(contextWindow).fireEvent(this);
+    fire() {
+        IframeEventBus.get().fireEvent(this);
     }
 
-    static getEventBus(contextWindow: Window): IframeEventBus {
-        return IframeEventBus.get(contextWindow);
+    toMessage(): string {
+        return '';
+    }
+
+    static fromMessage(name: string, data: string): IframeEvent {
+        return new IframeEvent(name);
+    }
+
+    static getEventBus(): IframeEventBus {
+        return IframeEventBus.get();
     }
 }

src/main/resources/assets/admin/common/js/event/IframeEventBus.ts

@@ -10,37 +10,42 @@ export class IframeEventBus
 
     private constructor(contextWindow: Window) {
         super(contextWindow);
-        this.ensureListener();
+
+        if (!this.isListening) {
+            this.contextWindow.addEventListener('message', this.handleMessageEvent);
+            this.isListening = true;
+        }
     }
 
-    static get(contextWindow: Window = window): IframeEventBus {
+    static init(contextWindow: Window): IframeEventBus {
+        if (IframeEventBus.instance) {
+            throw new Error(`IframeEventBus instance already initialized on ${IframeEventBus.instance.contextWindow.location.pathname}`);
+        }
+        console.info(`Initializing IframeEventBus instance by ${window.location.pathname} on ${contextWindow.location.pathname}`);
+        IframeEventBus.instance = new IframeEventBus(contextWindow);
+        return IframeEventBus.instance;
+    }
+
+    static get(): IframeEventBus {
         if (!IframeEventBus.instance) {
-            IframeEventBus.instance = new IframeEventBus(contextWindow);
-        } else if (IframeEventBus.instance.contextWindow !== contextWindow) {
-            throw new Error('IframeEventBus instance already created with a different contextWindow');
+            throw new Error('IframeEventBus instance should be initialized with a contextWindow first');
         }
         return IframeEventBus.instance;
     }
 
     public fireEvent(event: IframeEvent) {
         this.contextWindow.parent.postMessage({
             eventName: event.getName(),
-            detail: event
+            detail: event.toMessage()
         }, '*');
     }
 
-    private ensureListener() {
-        if (!this.isListening) {
-            this.contextWindow.addEventListener('message', this.handleMessageEvent);
-            this.isListening = true;
-        }
-    }
-
     private handleMessageEvent = (event: MessageEvent) => {
         const {eventName, detail} = event.data || {};
         if (!eventName) {
             return;
         }
+        //TODO: create event object from detail!
         (this.handlersMap[eventName] || []).forEach(entry => entry.handler(detail));
     };