khadhroony-bot3/migration/khadhroony-bot2-reference/kb_app_demo/frontend/ts/main.ts

// file: kb_app_demo/frontend/ts/main.ts
// version: 14

import * as bootstrap from "bootstrap";
import "simplebar";
import ResizeObserver from "resize-observer-polyfill";
import MarkdownIt from "markdown-it";
import { invoke } from "@tauri-apps/api/core";
import { frontendDebug, frontendError, installFrontendConsoleBridge } from "./frontend_log";

(window as Window & typeof globalThis & { bootstrap?: typeof bootstrap }).bootstrap = bootstrap;
(window as Window & typeof globalThis & { ResizeObserver?: typeof ResizeObserver }).ResizeObserver = ResizeObserver;

const markdownRenderer = new MarkdownIt({
    html: false,
    linkify: true,
    typographer: true,
});

function renderMarkdown(markdownText: string): string {
    return markdownRenderer.render(markdownText);
}

async function loadReadme(readmeContent: HTMLElement): Promise<void> {
    try {
        const readme = await invoke<string>("load_project_readme");
        readmeContent.innerHTML = renderMarkdown(readme);
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        readmeContent.textContent = `Erreur pendant le chargement du README : ${message}`;
        frontendError("kb_app_demo.frontend.main", `README loading failed: ${message}`);
    }
}

async function openDemoConfigWindow(): Promise<void> {
    try {
        await invoke("open_demo_config_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `Configuration demo window opening failed: ${message}`);
    }
}

async function openDemoHttpWindow(): Promise<void> {
    try {
        await invoke("open_demo_http_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `HTTP demo window opening failed: ${message}`);
    }
}


async function openDemoSqlDiagWindow(): Promise<void> {
    try {
        await invoke("open_demo_sql_diag_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `SQL diagnostics demo window opening failed: ${message}`);
    }
}

async function openDemoSqlPgRawWindow(): Promise<void> {
    try {
        await invoke("open_demo_sql_pg_raw_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `PostgreSQL raw demo window opening failed: ${message}`);
    }
}

async function openDemoSqlPgCoreWindow(): Promise<void> {
    try {
        await invoke("open_demo_sql_pg_core_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `PostgreSQL core demo window opening failed: ${message}`);
    }
}

async function openDemoSqlReplayCandidatesWindow(): Promise<void> {
    try {
        await invoke("open_demo_sql_replay_candidates_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `SQL replay candidates window opening failed: ${message}`);
    }
}

async function openDemoWsWindow(): Promise<void> {
    try {
        await invoke("open_demo_ws_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `WebSocket demo window opening failed: ${message}`);
    }
}

async function openDemoBackfillWindow(): Promise<void> {
    try {
        await invoke("open_demo_backfill_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `Backfill demo window opening failed: ${message}`);
    }
}

async function openDemoCoreExtractionWindow(): Promise<void> {
    try {
        await invoke("open_demo_core_extraction_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `Core extraction demo window opening failed: ${message}`);
    }
}

async function openDemoDecodeReplayWindow(): Promise<void> {
    try {
        await invoke("open_demo_decode_replay_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `Decode replay demo window opening failed: ${message}`);
    }
}

async function openDemoExecutionSolanaCoreWindow(): Promise<void> {
    try {
        await invoke("open_demo_execution_solana_core_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `Solana Devnet execution window opening failed: ${message}`);
    }
}

async function openDemoExecutionSplWindow(): Promise<void> {
    try {
        await invoke("open_demo_execution_spl_window");
    } catch (caughtError) {
        const message = caughtError instanceof Error ? caughtError.message : String(caughtError);
        frontendError("kb_app_demo.frontend.main", `SPL Devnet execution window opening failed: ${message}`);
    }
}

document.addEventListener("DOMContentLoaded", async () => {
    installFrontendConsoleBridge("kb_app_demo.frontend.main");

    frontendDebug("kb_app_demo.frontend.main", "main window loaded");

    const tooltipTriggerList = document.querySelectorAll('[data-bs-toggle="tooltip"]');
    Array.from(tooltipTriggerList).map(tooltipTriggerEl => new bootstrap.Tooltip(tooltipTriggerEl));
    const toastElList = document.querySelectorAll('.toast');
    Array.from(toastElList).map(toastEl => new bootstrap.Toast(toastEl));
    const popoverTriggerList = document.querySelectorAll('[data-bs-toggle="popover"]');
    Array.from(popoverTriggerList).map(popoverTriggerEl => new bootstrap.Popover(popoverTriggerEl));

    const readmeContent = document.querySelector<HTMLElement>("#readmeContent");
    if (readmeContent) {
        await loadReadme(readmeContent);
    }

    const openDemoConfigLink = document.querySelector<HTMLAnchorElement>("#openDemoConfigLink");
    if (openDemoConfigLink) {
        openDemoConfigLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoConfigWindow();
        });
    }

    const openDemoHttpLink = document.querySelector<HTMLAnchorElement>("#openDemoHttpLink");
    if (openDemoHttpLink) {
        openDemoHttpLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoHttpWindow();
        });
    }

    const openDemoWsLink = document.querySelector<HTMLAnchorElement>("#openDemoWsLink");
    if (openDemoWsLink) {
        openDemoWsLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoWsWindow();
        });
    }

    const openDemoBackfillLink = document.querySelector<HTMLAnchorElement>("#openDemoBackfillLink");
    if (openDemoBackfillLink) {
        openDemoBackfillLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoBackfillWindow();
        });
    }

    const openDemoCoreExtractionLink = document.querySelector<HTMLAnchorElement>("#openDemoCoreExtractionLink");
    if (openDemoCoreExtractionLink) {
        openDemoCoreExtractionLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoCoreExtractionWindow();
        });
    }

    const openDemoDecodeReplayLink = document.querySelector<HTMLAnchorElement>("#openDemoDecodeReplayLink");
    if (openDemoDecodeReplayLink) {
        openDemoDecodeReplayLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoDecodeReplayWindow();
        });
    }

    const openDemoExecutionSolanaCoreLink = document.querySelector<HTMLAnchorElement>("#openDemoExecutionSolanaCoreLink");
    if (openDemoExecutionSolanaCoreLink) {
        openDemoExecutionSolanaCoreLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoExecutionSolanaCoreWindow();
        });
    }

    const openDemoExecutionSplLink = document.querySelector<HTMLAnchorElement>("#openDemoExecutionSplLink");
    if (openDemoExecutionSplLink) {
        openDemoExecutionSplLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoExecutionSplWindow();
        });
    }

    const openDemoSqlDiagLink = document.querySelector<HTMLAnchorElement>("#openDemoSqlDiagLink");
    if (openDemoSqlDiagLink) {
        openDemoSqlDiagLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoSqlDiagWindow();
        });
    }

    const openDemoSqlPgRawLink = document.querySelector<HTMLAnchorElement>("#openDemoSqlPgRawLink");
    if (openDemoSqlPgRawLink) {
        openDemoSqlPgRawLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoSqlPgRawWindow();
        });
    }

    const openDemoSqlPgCoreLink = document.querySelector<HTMLAnchorElement>("#openDemoSqlPgCoreLink");
    if (openDemoSqlPgCoreLink) {
        openDemoSqlPgCoreLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoSqlPgCoreWindow();
        });
    }

    const openDemoSqlReplayCandidatesLink = document.querySelector<HTMLAnchorElement>("#openDemoSqlReplayCandidatesLink");
    if (openDemoSqlReplayCandidatesLink) {
        openDemoSqlReplayCandidatesLink.addEventListener("click", event => {
            event.preventDefault();
            void openDemoSqlReplayCandidatesWindow();
        });
    }
});