@shaper.org/core 1.0.2 → 1.0.4-prerelease

package/dist/client/index.d.mts

@@ -0,0 +1,61 @@
+//#region src/client/iframe-post-message.d.ts
+type PostMessageType = "server-ready" | "all-routes" | "route-change" | "route-refresh" | "error";
+interface PostMessage {
+  message: any;
+  type: PostMessageType;
+  object: "shaper-post-message";
+}
+interface RouteInfo {
+  name: string;
+  path: string;
+  file: string;
+}
+interface ServerReadyMessage extends PostMessage {
+  type: "server-ready";
+  message: {
+    satus: "ok";
+  };
+}
+interface AllRoutesMessage extends PostMessage {
+  type: "all-routes";
+  message: {
+    routes: RouteInfo[];
+  };
+}
+interface RouteChangeMessage extends PostMessage {
+  type: "route-change";
+  message: RouteInfo;
+}
+interface RouteRefreshMessage extends PostMessage {
+  type: "route-refresh";
+  message: RouteInfo;
+}
+interface ErrorInfo {
+  errorType: string;
+  timestamp: number;
+  lineno?: number;
+  colno?: number;
+  stack: string;
+  has_blank_screen: boolean;
+  filename?: string;
+}
+declare class IframePostMessageClient {
+  authHost: string;
+  private receiveCallbacks;
+  constructor();
+  _ensure_route_file(route: RouteInfo): void;
+  _send(message: PostMessage): void;
+  /**
+   * Allow consumers to register callbacks for incoming messages.
+   */
+  onMessage(callback: (event: MessageEvent<any>) => void): void;
+  onReceiveMessage(message: MessageEvent<any>): void;
+  sendServerReady(): void;
+  sendAllRoutes(routes: RouteInfo[]): void;
+  sendRouteChange(route: RouteInfo): void;
+  sendRouteRefresh(route: RouteInfo): void;
+  sendError(errorInfo: ErrorInfo): void;
+  sendConsole(): void;
+}
+//#endregion
+export { AllRoutesMessage, IframePostMessageClient, PostMessage, PostMessageType, RouteChangeMessage, RouteInfo, RouteRefreshMessage, ServerReadyMessage };

package/dist/client/index.mjs

@@ -0,0 +1,79 @@
+//#region src/client/iframe-post-message.ts
+var IframePostMessageClient = class {
+	authHost;
+	receiveCallbacks = [];
+	constructor() {
+		if (!import.meta.env) throw new Error("import.meta.env is not defined");
+		const AUTH_HOST = import.meta.env.VITE_FRONT_URL;
+		this.authHost = AUTH_HOST.endsWith("/") ? AUTH_HOST.slice(0, -1) : AUTH_HOST;
+		this.receiveCallbacks = [];
+		this.onReceiveMessage = this.onReceiveMessage.bind(this);
+		window.addEventListener("message", this.onReceiveMessage);
+	}
+	_ensure_route_file(route) {
+		if (!route.file.startsWith("src")) throw Error(`Invalid route file, route file should be relative to the root got: ${route.file}`);
+	}
+	_send(message) {
+		window.parent.postMessage(message, this.authHost);
+	}
+	/**
+	* Allow consumers to register callbacks for incoming messages.
+	*/
+	onMessage(callback) {
+		this.receiveCallbacks.push(callback);
+	}
+	onReceiveMessage(message) {
+		if (message.origin !== this.authHost) return;
+		for (const cb of this.receiveCallbacks) try {
+			cb(message);
+		} catch (err) {
+			console.error("Provided callback failed:", err);
+		}
+	}
+	sendServerReady() {
+		this._send({
+			type: "server-ready",
+			message: { satus: "ok" },
+			object: "shaper-post-message"
+		});
+	}
+	sendAllRoutes(routes) {
+		for (let route of routes) this._ensure_route_file(route);
+		const message = {
+			type: "all-routes",
+			message: { routes },
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendRouteChange(route) {
+		this._ensure_route_file(route);
+		const message = {
+			type: "route-change",
+			message: { ...route },
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendRouteRefresh(route) {
+		this._ensure_route_file(route);
+		const message = {
+			type: "route-refresh",
+			message: { ...route },
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendError(errorInfo) {
+		const message = {
+			type: "error",
+			message: errorInfo,
+			object: "shaper-post-message"
+		};
+		this._send(message);
+	}
+	sendConsole() {}
+};
+
+//#endregion
+export { IframePostMessageClient };

package/dist/node/index.d.mts

@@ -0,0 +1,27 @@
+import * as vite0 from "vite";
+import { HmrContext, ViteDevServer } from "vite";
+
+//#region src/node/hmr-events-plugin.d.ts
+declare const HMREventsPlugin: () => {
+  name: string;
+  enforce: string;
+  apply: string;
+  resolveId(id: string): "virtual:hmr-events-plugin" | undefined;
+  load(id: string): string | undefined;
+  transformIndexHtml(html: string): {
+    html: string;
+    tags: {
+      tag: string;
+      injectTo: string;
+      type: string;
+      attrs: {
+        src: string;
+        type: string;
+      };
+    }[];
+  };
+  configureServer(server: ViteDevServer): void;
+  handleHotUpdate(ctx: HmrContext): vite0.ModuleNode[];
+};
+//#endregion
+export { HMREventsPlugin };

package/dist/node/index.mjs

@@ -0,0 +1,48 @@
+import { fileURLToPath } from "url";
+
+//#region src/node/hmr-events-plugin.ts
+const HMREventsPlugin = () => {
+	return {
+		name: "hmr-events-plugin",
+		enforce: "post",
+		apply: "serve",
+		resolveId(id) {
+			if (id === "virtual:hmr-events-plugin") return id;
+		},
+		load(id) {
+			if (id === "virtual:hmr-events-plugin") {
+				const runtimePath = fileURLToPath(new URL("../runtime/error-tracker", import.meta.url));
+				return `import ${JSON.stringify(runtimePath)};`;
+			}
+		},
+		transformIndexHtml(html) {
+			return {
+				html,
+				tags: [{
+					tag: "script",
+					injectTo: "body",
+					type: "module",
+					attrs: {
+						src: "/@id/virtual:hmr-events-plugin",
+						type: "module"
+					}
+				}]
+			};
+		},
+		configureServer(server) {
+			server.ws.on("breeze:beforeUpdate", (event) => {});
+			server.ws.on("breeze:afterUpdate", (event) => {
+				for (let eventMessage of event.data) console.log(eventMessage.message);
+				console.log("[breeze] end update");
+			});
+		},
+		handleHotUpdate(ctx) {
+			const { file, timestamp, read, server, modules } = ctx;
+			console.log(`[breeze] hmr update: ${file}`);
+			return modules;
+		}
+	};
+};
+
+//#endregion
+export { HMREventsPlugin };

package/dist/runtime/error-tracker.ts

@@ -1,46 +1,22 @@
 import { ViteHook } from "./vite-hook";
 import { ViteMessage } from "./vite-message";
-
-interface LogEvent {
-    type: "logEvent";
-    logLevel: string;
-    timestamp: number;
-    message: string;
-}
-
-interface UnhandledrejectionEvent {
-    type: "unhandledrejectionEvent";
-    message: string;
-    timestamp: number;
-}
-
-interface ErrorEvent {
-    type: "errorEvent";
-    lineno: number;
-    colno: number;
-    filename: string;
-    message: string;
-    timestamp: number;
-}
-
-type Event = LogEvent | UnhandledrejectionEvent | ErrorEvent;
+import { IframePostMessageClient } from "../client";
 
 class ErrorTracker {
-    eventsQueue: Event[];
-
     public vHook: ViteHook;
     public viteMessage: ViteMessage;
+    private iframeClient: IframePostMessageClient;
 
     constructor() {
-        this.eventsQueue = [];
-
         this.viteMessage = new ViteMessage();
 
         this.vHook = new ViteHook();
+
+        this.iframeClient = new IframePostMessageClient();
     }
 
     isBlankScreen() {
-        const app = document.querySelector("div#app");
+        const app = document.querySelector("div#root");
         return app ? app.childElementCount === 0 : false;
     }
 
@@ -48,35 +24,29 @@ class ErrorTracker {
         this.handleError();
         this.handleUnhandledrejection();
         this.consoleInterception();
+    }
 
-        let startTimestamp: number;
-        this.vHook.onBeforeUpdate((data, timestamp) => {
-            startTimestamp = timestamp;
-            this.viteMessage.sendBeforeUpdate(data);
-        });
-
-        this.vHook.onError((data, timestamp) => {
-            console.debug(data);
-        });
-
-        this.vHook.onAfterUpdate((data, timestamp) => {
-            setTimeout(() => {
-                const endTimestamp = Date.now();
-
-                let events = this.eventsQueue.filter(
-                    (event) =>
-                        event.timestamp >= startTimestamp &&
-                        event.timestamp <= endTimestamp,
-                );
+    formatConsoleMessage(args: unknown[]): string {
+        let error;
+        const texts = [];
+        for (let arg of args) {
+            if (arg instanceof Error) {
+                error = arg;
+            } else {
+                texts.push(arg);
+            }
+        }
 
-                this.viteMessage.sendAfterUpdate(events);
+        if (error) {
+            return error.stack || error.message;
+        }
 
-                this.eventsQueue = [];
-            }, 5);
-        });
+        return texts.map((text) => String(text)).join(" ");
     }
 
     consoleInterception() {
+        type LogLevel = keyof typeof originalConsole;
+
         const originalConsole = {
             log: console.log,
             warn: console.warn,
@@ -84,83 +54,63 @@ class ErrorTracker {
             trace: console.trace,
             //   debug: console.debug,
         };
-
-        for (let logLevel of Object.keys(originalConsole)) {
-            console[logLevel] = function (...args) {
-                const logArgumentsString = args.map((arg) => {
-                    if (arg) {
-                        return arg.toString();
-                    }
-                });
-
-                this.eventsQueue.push({
-                    type: "logEvent",
-                    logLevel,
-                    timestamp: Date.now(),
-                    message: logArgumentsString.join(" "),
-                });
+        for (let logLevel of Object.keys(originalConsole) as LogLevel[]) {
+            console[logLevel] = function (
+                this: ErrorTracker,
+                ...args: unknown[]
+            ) {
                 originalConsole[logLevel].apply(this, args);
+
+                const message = this.formatConsoleMessage(args);
+
+                if (!message) return;
+
+                if (logLevel === "error") {
+                    console.debug("console error", message);
+                    this.iframeClient.sendError({
+                        errorType: "RUNTIME_ERROR",
+                        timestamp: Date.now(),
+                        stack: message,
+                        has_blank_screen: this.isBlankScreen(),
+                    });
+                }
             }.bind(this);
         }
     }
 
     handleUnhandledrejection() {
         window.addEventListener("unhandledrejection", (evt) => {
-            console.debug(evt);
-            const UnhandledrejectionMessage = {
-                type: "unhandledrejectionEvent",
-                message: evt.reason.stack || evt.reason.message,
+            console.debug("handleUnhandledrejection", evt);
+            this.iframeClient.sendError({
+                errorType: "RUNTIME_ERROR",
                 timestamp: Date.now(),
-            };
-
-            this.eventsQueue.push(UnhandledrejectionMessage);
+                stack: evt.reason.stack || evt.reason.message,
+                has_blank_screen: this.isBlankScreen(),
+            });
         });
     }
 
     handleError() {
         window.addEventListener("error", (evt) => {
+            console.debug("handleError", evt);
             let message;
             if (evt.error) {
                 message = evt.error.stack || evt.error.message;
             } else {
                 message = evt.message;
             }
-
-            console.debug(evt);
-            const errorMessage = {
-                type: "errorEvent",
+            this.iframeClient.sendError({
+                errorType: "RUNTIME_ERROR",
+                timestamp: Date.now(),
+                stack: message,
+                has_blank_screen: this.isBlankScreen(),
                 lineno: evt.lineno,
                 colno: evt.colno,
                 filename: evt.filename,
-                message: message,
-                timestamp: Date.now(),
-            };
-
-            this.eventsQueue.push(errorMessage);
+            });
         });
-
-        // This handle the following kind of runtime error
-        // For now it's diffcult to know what to do because those errors are not sync with the HMR lifecyle
-        // Maybe use a queue
-        // <script setup lang="ts">
-        // import { onMounted } from 'vue';
-
-        // onMounted(() => {
-        //   // This will trigger the error event because it happens at runtime
-        //   setTimeout(() => {
-        //     undefinedFunction(); // Runtime error - WILL trigger window.error
-        //   }, 0);
-        // });
-        // </script>
     }
 }
 
 const tracker = new ErrorTracker();
 tracker.start();
-
-// HMR listening
-// const handleMessage = (event) => {
-//   console.log(event);
-// };
-
-// window.addEventListener("message", handleMessage);

package/dist/runtime/vite-hook.ts

@@ -1,133 +1,134 @@
 import {
-  ErrorPayload,
-  FullReloadPayload,
-  PrunePayload,
-  UpdatePayload,
+    ErrorPayload,
+    FullReloadPayload,
+    PrunePayload,
+    UpdatePayload,
 } from "vite/types/hmrPayload.js";
 import { ViteHotContext } from "vite/types/hot.js";
 
 type ViteUpdateCallback =
-  | ((data: UpdatePayload, timestamp: number) => void)
-  | null;
+    | ((data: UpdatePayload, timestamp: number) => void)
+    | null;
 
 type VitePruneCallback =
-  | ((data: PrunePayload, timestamp: number) => void)
-  | null;
+    | ((data: PrunePayload, timestamp: number) => void)
+    | null;
 
 type VitFullReloadCallback =
-  | ((data: FullReloadPayload, timestamp: number) => void)
-  | null;
+    | ((data: FullReloadPayload, timestamp: number) => void)
+    | null;
 
 type ViteErrorCallback =
-  | ((data: ErrorPayload, timestamp: number) => void)
-  | null;
+    | ((data: ErrorPayload, timestamp: number) => void)
+    | null;
 
 type ViteInvalidateCallback = ((data: any, timestamp: number) => void) | null;
 
 type ViteWebSocketConnectCallback =
-  | ((data: any, timestamp: number) => void)
-  | null;
+    | ((data: any, timestamp: number) => void)
+    | null;
 
 type ViteWebSocketDisconnectCallback =
-  | ((data: any, timestamp: number) => void)
-  | null;
+    | ((data: any, timestamp: number) => void)
+    | null;
 
 class ViteHook {
-  private hmr: ViteHotContext | undefined;
-  constructor() {
-    this.hmr = import.meta.hot;
-  }
-  hotExists(hmr: ViteHotContext | undefined): hmr is ViteHotContext {
-    if (hmr) return true;
-    console.error("HotContext does not exists");
-    return false;
-  }
-
-  onBeforeUpdate(fn: ViteUpdateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforeUpdate", (data: UpdatePayload) => {
-      const timestamp = Date.now();
-      console.debug("beforeUpdate");
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onAfterUpdate(fn: ViteUpdateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:afterUpdate", (data: UpdatePayload) => {
-      const timestamp = Date.now();
-      console.debug("afterUpdate");
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onBeforePrune(fn: VitePruneCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforePrune", (data: PrunePayload) => {
-      const timestamp = Date.now();
-      console.debug("beforePrune");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onBeforeFullReload(fn: VitFullReloadCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforeFullReload", (data: FullReloadPayload) => {
-      const timestamp = Date.now();
-      console.debug("beforeFullReload");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onError(fn: ViteErrorCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:error", (data: ErrorPayload) => {
-      const timestamp = Date.now();
-      console.debug("error");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onInvalidate(fn: ViteInvalidateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:invalidate", (data: any) => {
-      const timestamp = Date.now();
-      console.debug("invalidate");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onWsConnect(fn: ViteWebSocketConnectCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:ws:connect", (data: any) => {
-      const timestamp = Date.now();
-      console.debug("ws:connect");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onWsDisconnect(fn: ViteWebSocketDisconnectCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:ws:disconnect", (data: any) => {
-      const timestamp = Date.now();
-      console.debug(":ws:disconnect");
-
-      fn && fn(data, timestamp);
-    });
-  }
+    private hmr: ViteHotContext | undefined;
+    constructor() {
+        this.hmr = import.meta.hot;
+    }
+    hotExists(hmr: ViteHotContext | undefined): hmr is ViteHotContext {
+        if (hmr) return true;
+        console.error("HotContext does not exists");
+        return false;
+    }
+
+    onBeforeUpdate(fn: ViteUpdateCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:beforeUpdate", (data: UpdatePayload) => {
+            const timestamp = Date.now();
+            console.debug("beforeUpdate");
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onAfterUpdate(fn: ViteUpdateCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:afterUpdate", (data: UpdatePayload) => {
+            const timestamp = Date.now();
+            console.debug("afterUpdate");
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onBeforePrune(fn: VitePruneCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:beforePrune", (data: PrunePayload) => {
+            const timestamp = Date.now();
+            console.debug("beforePrune");
+
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onBeforeFullReload(fn: VitFullReloadCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:beforeFullReload", (data: FullReloadPayload) => {
+            const timestamp = Date.now();
+            console.debug("beforeFullReload");
+
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onError(fn: ViteErrorCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:error", (data: ErrorPayload) => {
+            const timestamp = Date.now();
+            console.debug("error");
+            console.log(this.hmr);
+
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onInvalidate(fn: ViteInvalidateCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:invalidate", (data: any) => {
+            const timestamp = Date.now();
+            console.debug("invalidate");
+
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onWsConnect(fn: ViteWebSocketConnectCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:ws:connect", (data: any) => {
+            const timestamp = Date.now();
+            console.debug("ws:connect");
+
+            fn && fn(data, timestamp);
+        });
+    }
+
+    onWsDisconnect(fn: ViteWebSocketDisconnectCallback = null) {
+        if (!this.hotExists(this.hmr)) return;
+
+        this.hmr.on("vite:ws:disconnect", (data: any) => {
+            const timestamp = Date.now();
+            console.debug(":ws:disconnect");
+
+            fn && fn(data, timestamp);
+        });
+    }
 }
 
 export { ViteHook };

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "@shaper.org/core",
-  "version": "1.0.2",
+  "version": "1.0.4-prerelease",
   "description": "",
   "type": "module",
   "private": false,
   "files": [
-    "dist",
-    "src/runtime"
+    "dist"
   ],
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "types": "./dist/index.d.ts"
     },
+    "./client": {
+      "import": "./dist/client/index.mjs",
+      "types": "./dist/client/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node/index.mjs",
+      "types": "./dist/node/index.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
@@ -47,6 +54,10 @@
     ],
     "copy": [
       "src/runtime/"
+    ],
+    "entry": [
+      "src/node/index.ts",
+      "src/client/index.ts"
     ]
   },
   "publishConfig": {

package/dist/index.d.mts

@@ -1,72 +0,0 @@
-import * as vite0 from "vite";
-import { HmrContext, ViteDevServer } from "vite";
-
-//#region src/iframe-post-message.d.ts
-type PostMessageType = "server-ready" | "all-routes" | "route-change" | "route-refresh";
-interface PostMessage {
-  message: any;
-  type: PostMessageType;
-}
-interface RouteInfo {
-  name: string;
-  path: string;
-  file: string;
-}
-interface ServerReadyMessage extends PostMessage {
-  type: "server-ready";
-  message: {
-    satus: "ok";
-  };
-}
-interface AllRoutesMessage extends PostMessage {
-  type: "all-routes";
-  message: {
-    routes: RouteInfo[];
-  };
-}
-interface RouteChangeMessage extends PostMessage {
-  type: "route-change";
-  message: {
-    route: RouteInfo;
-  };
-}
-interface RouteRefreshMessage extends PostMessage {
-  type: "route-refresh";
-  message: {
-    route: RouteInfo;
-  };
-}
-declare class IframePostMessageClient {
-  authHost: string;
-  constructor();
-  _ensure_route_file(route: RouteInfo): void;
-  _send(message: PostMessage): void;
-  sendServerReady(): void;
-  sendAllRoutes(routes: RouteInfo[]): void;
-  sendRouteChange(route: RouteInfo): void;
-  sendRouteRefresh(route: RouteInfo): void;
-}
-//#endregion
-//#region src/hmr-events-plugin.d.ts
-declare const HMREventsPlugin: () => {
-  name: string;
-  enforce: string;
-  resolveId(id: string): "virtual:hmr-events-plugin" | undefined;
-  load(id: string): string | undefined;
-  transformIndexHtml(html: string): {
-    html: string;
-    tags: {
-      tag: string;
-      injectTo: string;
-      type: string;
-      attrs: {
-        src: string;
-        type: string;
-      };
-    }[];
-  };
-  configureServer(server: ViteDevServer): void;
-  handleHotUpdate(ctx: HmrContext): vite0.ModuleNode[];
-};
-//#endregion
-export { AllRoutesMessage, HMREventsPlugin, IframePostMessageClient, PostMessage, PostMessageType, RouteChangeMessage, RouteInfo, RouteRefreshMessage, ServerReadyMessage };

package/dist/index.mjs

@@ -1,94 +0,0 @@
-import { fileURLToPath } from "url";
-
-//#region src/iframe-post-message.ts
-var IframePostMessageClient = class {
-	authHost;
-	constructor() {
-		if (!import.meta.env) throw new Error("import.meta.env is not defined");
-		const AUTH_HOST = import.meta.env.VITE_FRONT_URL;
-		this.authHost = AUTH_HOST.endsWith("/") ? AUTH_HOST.slice(0, -1) : AUTH_HOST;
-	}
-	_ensure_route_file(route) {
-		if (!route.file.startsWith("src")) throw Error(`Invalid route path, route path should be relative to the root got: ${route.file}`);
-	}
-	_send(message) {
-		window.parent.postMessage(message, this.authHost);
-	}
-	sendServerReady() {
-		this._send({
-			type: "server-ready",
-			message: { satus: "ok" }
-		});
-	}
-	sendAllRoutes(routes) {
-		for (let route of routes) this._ensure_route_file(route);
-		const message = {
-			type: "all-routes",
-			message: { routes }
-		};
-		this._send(message);
-	}
-	sendRouteChange(route) {
-		this._ensure_route_file(route);
-		const message = {
-			type: "route-change",
-			message: { route }
-		};
-		this._send(message);
-	}
-	sendRouteRefresh(route) {
-		this._ensure_route_file(route);
-		const message = {
-			type: "route-refresh",
-			message: { route }
-		};
-		this._send(message);
-	}
-};
-
-//#endregion
-//#region src/hmr-events-plugin.ts
-const HMREventsPlugin = () => {
-	return {
-		name: "hmr-events-plugin",
-		enforce: "pre",
-		resolveId(id) {
-			if (id === "virtual:hmr-events-plugin") return id;
-		},
-		load(id) {
-			if (id === "virtual:hmr-events-plugin") {
-				const runtimePath = fileURLToPath(new URL("./runtime/error-tracker", import.meta.url));
-				return `import ${JSON.stringify(runtimePath)};`;
-			}
-		},
-		transformIndexHtml(html) {
-			return {
-				html,
-				tags: [{
-					tag: "script",
-					injectTo: "body",
-					type: "module",
-					attrs: {
-						src: "/@id/virtual:hmr-events-plugin",
-						type: "module"
-					}
-				}]
-			};
-		},
-		configureServer(server) {
-			server.ws.on("breeze:beforeUpdate", (event) => {});
-			server.ws.on("breeze:afterUpdate", (event) => {
-				for (let eventMessage of event.data) console.log(eventMessage.message);
-				console.log("[breeze] end update");
-			});
-		},
-		handleHotUpdate(ctx) {
-			const { file, timestamp, read, server, modules } = ctx;
-			console.log(`[breeze] hmr update: ${file}`);
-			return modules;
-		}
-	};
-};
-
-//#endregion
-export { HMREventsPlugin, IframePostMessageClient };

package/src/runtime/error-tracker.ts

@@ -1,166 +0,0 @@
-import { ViteHook } from "./vite-hook";
-import { ViteMessage } from "./vite-message";
-
-interface LogEvent {
-    type: "logEvent";
-    logLevel: string;
-    timestamp: number;
-    message: string;
-}
-
-interface UnhandledrejectionEvent {
-    type: "unhandledrejectionEvent";
-    message: string;
-    timestamp: number;
-}
-
-interface ErrorEvent {
-    type: "errorEvent";
-    lineno: number;
-    colno: number;
-    filename: string;
-    message: string;
-    timestamp: number;
-}
-
-type Event = LogEvent | UnhandledrejectionEvent | ErrorEvent;
-
-class ErrorTracker {
-    eventsQueue: Event[];
-
-    public vHook: ViteHook;
-    public viteMessage: ViteMessage;
-
-    constructor() {
-        this.eventsQueue = [];
-
-        this.viteMessage = new ViteMessage();
-
-        this.vHook = new ViteHook();
-    }
-
-    isBlankScreen() {
-        const app = document.querySelector("div#app");
-        return app ? app.childElementCount === 0 : false;
-    }
-
-    start() {
-        this.handleError();
-        this.handleUnhandledrejection();
-        this.consoleInterception();
-
-        let startTimestamp: number;
-        this.vHook.onBeforeUpdate((data, timestamp) => {
-            startTimestamp = timestamp;
-            this.viteMessage.sendBeforeUpdate(data);
-        });
-
-        this.vHook.onError((data, timestamp) => {
-            console.debug(data);
-        });
-
-        this.vHook.onAfterUpdate((data, timestamp) => {
-            setTimeout(() => {
-                const endTimestamp = Date.now();
-
-                let events = this.eventsQueue.filter(
-                    (event) =>
-                        event.timestamp >= startTimestamp &&
-                        event.timestamp <= endTimestamp,
-                );
-
-                this.viteMessage.sendAfterUpdate(events);
-
-                this.eventsQueue = [];
-            }, 5);
-        });
-    }
-
-    consoleInterception() {
-        const originalConsole = {
-            log: console.log,
-            warn: console.warn,
-            error: console.error,
-            trace: console.trace,
-            //   debug: console.debug,
-        };
-
-        for (let logLevel of Object.keys(originalConsole)) {
-            console[logLevel] = function (...args) {
-                const logArgumentsString = args.map((arg) => {
-                    if (arg) {
-                        return arg.toString();
-                    }
-                });
-
-                this.eventsQueue.push({
-                    type: "logEvent",
-                    logLevel,
-                    timestamp: Date.now(),
-                    message: logArgumentsString.join(" "),
-                });
-                originalConsole[logLevel].apply(this, args);
-            }.bind(this);
-        }
-    }
-
-    handleUnhandledrejection() {
-        window.addEventListener("unhandledrejection", (evt) => {
-            console.debug(evt);
-            const UnhandledrejectionMessage = {
-                type: "unhandledrejectionEvent",
-                message: evt.reason.stack || evt.reason.message,
-                timestamp: Date.now(),
-            };
-
-            this.eventsQueue.push(UnhandledrejectionMessage);
-        });
-    }
-
-    handleError() {
-        window.addEventListener("error", (evt) => {
-            let message;
-            if (evt.error) {
-                message = evt.error.stack || evt.error.message;
-            } else {
-                message = evt.message;
-            }
-
-            console.debug(evt);
-            const errorMessage = {
-                type: "errorEvent",
-                lineno: evt.lineno,
-                colno: evt.colno,
-                filename: evt.filename,
-                message: message,
-                timestamp: Date.now(),
-            };
-
-            this.eventsQueue.push(errorMessage);
-        });
-
-        // This handle the following kind of runtime error
-        // For now it's diffcult to know what to do because those errors are not sync with the HMR lifecyle
-        // Maybe use a queue
-        // <script setup lang="ts">
-        // import { onMounted } from 'vue';
-
-        // onMounted(() => {
-        //   // This will trigger the error event because it happens at runtime
-        //   setTimeout(() => {
-        //     undefinedFunction(); // Runtime error - WILL trigger window.error
-        //   }, 0);
-        // });
-        // </script>
-    }
-}
-
-const tracker = new ErrorTracker();
-tracker.start();
-
-// HMR listening
-// const handleMessage = (event) => {
-//   console.log(event);
-// };
-
-// window.addEventListener("message", handleMessage);

package/src/runtime/vite-hook.ts

@@ -1,133 +0,0 @@
-import {
-  ErrorPayload,
-  FullReloadPayload,
-  PrunePayload,
-  UpdatePayload,
-} from "vite/types/hmrPayload.js";
-import { ViteHotContext } from "vite/types/hot.js";
-
-type ViteUpdateCallback =
-  | ((data: UpdatePayload, timestamp: number) => void)
-  | null;
-
-type VitePruneCallback =
-  | ((data: PrunePayload, timestamp: number) => void)
-  | null;
-
-type VitFullReloadCallback =
-  | ((data: FullReloadPayload, timestamp: number) => void)
-  | null;
-
-type ViteErrorCallback =
-  | ((data: ErrorPayload, timestamp: number) => void)
-  | null;
-
-type ViteInvalidateCallback = ((data: any, timestamp: number) => void) | null;
-
-type ViteWebSocketConnectCallback =
-  | ((data: any, timestamp: number) => void)
-  | null;
-
-type ViteWebSocketDisconnectCallback =
-  | ((data: any, timestamp: number) => void)
-  | null;
-
-class ViteHook {
-  private hmr: ViteHotContext | undefined;
-  constructor() {
-    this.hmr = import.meta.hot;
-  }
-  hotExists(hmr: ViteHotContext | undefined): hmr is ViteHotContext {
-    if (hmr) return true;
-    console.error("HotContext does not exists");
-    return false;
-  }
-
-  onBeforeUpdate(fn: ViteUpdateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforeUpdate", (data: UpdatePayload) => {
-      const timestamp = Date.now();
-      console.debug("beforeUpdate");
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onAfterUpdate(fn: ViteUpdateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:afterUpdate", (data: UpdatePayload) => {
-      const timestamp = Date.now();
-      console.debug("afterUpdate");
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onBeforePrune(fn: VitePruneCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforePrune", (data: PrunePayload) => {
-      const timestamp = Date.now();
-      console.debug("beforePrune");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onBeforeFullReload(fn: VitFullReloadCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:beforeFullReload", (data: FullReloadPayload) => {
-      const timestamp = Date.now();
-      console.debug("beforeFullReload");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onError(fn: ViteErrorCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:error", (data: ErrorPayload) => {
-      const timestamp = Date.now();
-      console.debug("error");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onInvalidate(fn: ViteInvalidateCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:invalidate", (data: any) => {
-      const timestamp = Date.now();
-      console.debug("invalidate");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onWsConnect(fn: ViteWebSocketConnectCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:ws:connect", (data: any) => {
-      const timestamp = Date.now();
-      console.debug("ws:connect");
-
-      fn && fn(data, timestamp);
-    });
-  }
-
-  onWsDisconnect(fn: ViteWebSocketDisconnectCallback = null) {
-    if (!this.hotExists(this.hmr)) return;
-
-    this.hmr.on("vite:ws:disconnect", (data: any) => {
-      const timestamp = Date.now();
-      console.debug(":ws:disconnect");
-
-      fn && fn(data, timestamp);
-    });
-  }
-}
-
-export { ViteHook };

package/src/runtime/vite-message.ts

@@ -1,61 +0,0 @@
-import { ViteHotContext } from "vite/types/hot.js";
-
-interface MessageEvent {
-  type: "custom";
-  event: string;
-  data: any;
-}
-
-enum MessageEventType {
-  BEFORE_UPDATE = "breeze:beforeUpdate",
-  AFTER_UPDATE = "breeze:afterUpdate",
-  ERROR = "breeze:error",
-}
-
-class ViteMessage {
-  private server: ViteHotContext | undefined;
-
-  constructor() {
-    this.server = import.meta.hot;
-  }
-
-  hotExists(server: ViteHotContext | undefined): server is ViteHotContext {
-    if (server) return true;
-    console.error("HotContext does not exists");
-    return false;
-  }
-
-  send(event: string, message: MessageEvent) {
-    if (!this.hotExists(this.server)) return;
-    this.server.send(event, message);
-  }
-
-  sendBeforeUpdate(data: any) {
-    if (!this.hotExists(this.server)) return;
-    this.server.send(MessageEventType.BEFORE_UPDATE, {
-      type: "custom",
-      event: MessageEventType.BEFORE_UPDATE,
-      data: data,
-    });
-  }
-
-  sendError(data: any) {
-    if (!this.hotExists(this.server)) return;
-    this.server.send(MessageEventType.ERROR, {
-      type: "custom",
-      event: MessageEventType.ERROR,
-      data: data,
-    });
-  }
-
-  sendAfterUpdate(data: any) {
-    if (!this.hotExists(this.server)) return;
-    this.server.send(MessageEventType.AFTER_UPDATE, {
-      type: "custom",
-      event: MessageEventType.AFTER_UPDATE,
-      data: data,
-    });
-  }
-}
-
-export { ViteMessage };