Implement "import history" in import page

app/composeables/api/event-source.ts

@@ -0,0 +1,94 @@
+import type { AxiosRequestConfig } from "axios";
+import { ErrorEvent, EventSource } from 'eventsource'
+
+type Unarray<T> = T extends Array<infer U> ? U : T;
+
+export interface EventSourceListener<T> {
+    handle: (callback: (data: T) => void) => EventSourceListener<T>;
+    close: () => void;
+    onError: (callback: (error: ErrorEvent) => void) => EventSourceListener<T>;
+    onOpen: (callback: (event: Event) => void) => EventSourceListener<T>;
+}
+
+const eventSource = <T>(
+    config: AxiosRequestConfig,
+    options?: AxiosRequestConfig,
+): Promise<EventSourceListener<Unarray<T>>> => {
+    return new Promise((resolve, reject) => {
+        try {
+            const baseURL = useRuntimeConfig().public.apiBaseUrl;
+            const endpoint = config.url;
+            const eventSource = new EventSource(baseURL + endpoint, {
+                fetch: (input, init) => fetch(input, {
+                    ...init,
+                    headers: {
+                        ...init.headers,
+                        Authorization: 'Basic ' + btoa('user1' + ":" + 'password'),
+                    },
+                })
+            })
+
+            let messageCallback: ((data: Unarray<T>) => void) | null = null;
+            let errorCallback: ((error: ErrorEvent) => void) | null = null;
+            let openCallback: ((event: Event) => void) | null = null;
+
+            eventSource.addEventListener("message", (event: MessageEvent<any>) => {
+                if (messageCallback) {
+                    try {
+                        let data = JSON.parse(event.data) as Unarray<T>;
+                        messageCallback(data);
+                    } catch (error) {
+                        console.error('Error parsing EventSource data:', error);
+                    }
+                }
+            });
+
+            eventSource.addEventListener('error', (event) => {
+                if (errorCallback) {
+                    errorCallback(event);
+                }
+            });
+
+            eventSource.addEventListener('open', (event) => {
+                if (openCallback) {
+                    openCallback(event);
+                }
+            });
+
+            const listener: EventSourceListener<Unarray<T>> = {
+                handle: (callback: (data: Unarray<T>) => void) => {
+                    messageCallback = callback;
+                    return listener;
+                },
+
+                onError: (callback: (error: ErrorEvent) => void) => {
+                    errorCallback = callback;
+                    return listener;
+                },
+
+                onOpen: (callback: (event: Event) => void) => {
+                    openCallback = callback;
+                    return listener;
+                },
+
+                close: () => {
+                    eventSource.close();
+                    messageCallback = null;
+                    errorCallback = null;
+                    openCallback = null;
+                }
+            };
+
+            resolve(listener);
+            setTimeout(() => {
+                if (eventSource.readyState === EventSource.CLOSED && !errorCallback) {
+                    reject(new Error('EventSource connection failed'));
+                }
+            }, 5000);
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+export default eventSource;