testeranto 0.200.0 → 0.202.0

package/dist/module/src/PM/metafileOutputs.js

@@ -0,0 +1,78 @@
+"use strict";
+// import { IRunTime } from "../Types";
+// import { IOutputs, filesHash } from "./utils";
+// import ansiC from "ansi-colors";
+// import fs from "fs";
+// export const metafileOutputs = async (platform: IRunTime) => {
+//   let metafilePath: string;
+//   if (platform === "python") {
+//     metafilePath = `./testeranto/metafiles/python/core.json`;
+//   } else {
+//     metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
+//   }
+//   // Check if the file exists
+//   if (!fs.existsSync(metafilePath)) {
+//     if (platform === "python") {
+//       console.log(
+//         ansiC.yellow(
+//           ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`)
+//         )
+//       );
+//     }
+//     return;
+//   }
+//   let metafile;
+//   try {
+//     const fileContent = fs.readFileSync(metafilePath).toString();
+//     const parsedData = JSON.parse(fileContent);
+//     // Handle different metafile structures
+//     if (platform === "python") {
+//       // Pitono metafile might be the entire content or have a different structure
+//       metafile = parsedData.metafile || parsedData;
+//     } else {
+//       metafile = parsedData.metafile;
+//     }
+//     if (!metafile) {
+//       console.log(
+//         ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
+//       );
+//       return;
+//     }
+//   } catch (error) {
+//     console.error(`Error reading metafile at ${metafilePath}:`, error);
+//     return;
+//   }
+//   const outputs: IOutputs = metafile.outputs;
+//   Object.keys(outputs).forEach(async (k) => {
+//     const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
+//     if (!k.startsWith(pattern)) {
+//       return false;
+//     }
+//     const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+//       if (!fs.existsSync(i)) return false;
+//       if (i.startsWith("node_modules")) return false;
+//       if (i.startsWith("./node_modules")) return false;
+//       return true;
+//     });
+//     const f = `${k.split(".").slice(0, -1).join(".")}/`;
+//     if (!fs.existsSync(f)) {
+//       fs.mkdirSync(f);
+//     }
+//     const entrypoint = outputs[k].entryPoint;
+//     if (entrypoint) {
+//       const changeDigest = await filesHash(addableFiles);
+//       if (changeDigest === changes[entrypoint]) {
+//         // skip
+//       } else {
+//         changes[entrypoint] = changeDigest;
+//         this.tscCheck({
+//           platform,
+//           addableFiles,
+//           entrypoint: entrypoint,
+//         });
+//         this.eslintCheck(entrypoint, platform, addableFiles);
+//         this.makePrompt(entrypoint, addableFiles, platform);
+//       }
+//     }
+//   });
+// };

package/dist/module/src/PM/node.js

@@ -38,12 +38,6 @@ export class PM_Node extends PM {
             this.client.write(JSON.stringify([command, ...argz, key]));
         });
     }
-    async launchSideCar(n) {
-        return this.send("launchSideCar", n, this.testResourceConfiguration.name);
-    }
-    stopSideCar(n) {
-        return this.send("stopSideCar", n, this.testResourceConfiguration.name);
-    }
     async pages() {
         return this.send("pages", ...arguments);
     }

package/dist/module/src/PM/pure.js

@@ -6,9 +6,6 @@ export class PM_Pure extends PM {
     getInnerHtml(selector, page) {
         throw new Error("pure.ts getInnerHtml not implemented");
     }
-    stopSideCar(uid) {
-        throw new Error("pure.ts stopSideCar not implemented");
-    }
     constructor(t) {
         super();
         this.server = {};
@@ -25,10 +22,6 @@ export class PM_Pure extends PM {
     }
     async createWriteStream(filepath, testName) {
         throw new Error("pure.ts createWriteStream not implemented");
-        return "";
-    }
-    launchSideCar(n) {
-        return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
     }
     pages() {
         return globalThis["pages"]();
@@ -91,7 +84,6 @@ export class PM_Pure extends PM {
     writeFileSync() {
         return Promise.resolve(true);
     }
-    /////////////////////////////////////////////////////
     end(uid) {
         return globalThis["end"](uid);
     }

package/dist/module/src/PM/types.js

@@ -1 +1 @@
-"use strict";
+export {};

package/dist/module/src/PM/utils.js

@@ -0,0 +1,196 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import ansiC from "ansi-colors";
+import path from "path";
+import fs from "fs";
+import crypto from "node:crypto";
+export function runtimeLogs(runtime, reportDest) {
+    const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+    try {
+        if (!fs.existsSync(safeDest)) {
+            fs.mkdirSync(safeDest, { recursive: true });
+        }
+        if (runtime === "node") {
+            return {
+                stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "web") {
+            return {
+                info: fs.createWriteStream(`${safeDest}/info.log`),
+                warn: fs.createWriteStream(`${safeDest}/warn.log`),
+                error: fs.createWriteStream(`${safeDest}/error.log`),
+                debug: fs.createWriteStream(`${safeDest}/debug.log`),
+                exit: fs.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "pure") {
+            return {
+                exit: fs.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "pitono") {
+            return {
+                stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else {
+            throw `unknown runtime: ${runtime}`;
+        }
+    }
+    catch (e) {
+        console.error(`Failed to create log streams in ${safeDest}:`, e);
+        throw e;
+    }
+}
+export function createLogStreams(reportDest, runtime) {
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(reportDest)) {
+        fs.mkdirSync(reportDest, { recursive: true });
+    }
+    // const streams = {
+    //   exit: fs.createWriteStream(`${reportDest}/exit.log`),
+    const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+    try {
+        if (!fs.existsSync(safeDest)) {
+            fs.mkdirSync(safeDest, { recursive: true });
+        }
+        const streams = runtimeLogs(runtime, safeDest);
+        // const streams = {
+        //   exit: fs.createWriteStream(`${safeDest}/exit.log`),
+        //   ...(runtime === "node" || runtime === "pure"
+        //     ? {
+        //         stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        //         stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        //       }
+        //     : {
+        //         info: fs.createWriteStream(`${safeDest}/info.log`),
+        //         warn: fs.createWriteStream(`${safeDest}/warn.log`),
+        //         error: fs.createWriteStream(`${safeDest}/error.log`),
+        //         debug: fs.createWriteStream(`${safeDest}/debug.log`),
+        //       }),
+        // };
+        return Object.assign(Object.assign({}, streams), { closeAll: () => {
+                Object.values(streams).forEach((stream) => !stream.closed && stream.close());
+            }, writeExitCode: (code, error) => {
+                if (error) {
+                    streams.exit.write(`Error: ${error.message}\n`);
+                    if (error.stack) {
+                        streams.exit.write(`Stack Trace:\n${error.stack}\n`);
+                    }
+                }
+                streams.exit.write(`${code}\n`);
+            }, exit: streams.exit });
+    }
+    catch (e) {
+        console.error(`Failed to create log streams in ${safeDest}:`, e);
+        throw e;
+    }
+}
+export async function fileHash(filePath, algorithm = "md5") {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash(algorithm);
+        const fileStream = fs.createReadStream(filePath);
+        fileStream.on("data", (data) => {
+            hash.update(data);
+        });
+        fileStream.on("end", () => {
+            const fileHash = hash.digest("hex");
+            resolve(fileHash);
+        });
+        fileStream.on("error", (error) => {
+            reject(`Error reading file: ${error.message}`);
+        });
+    });
+}
+export const statusMessagePretty = (failures, test, runtime) => {
+    if (failures === 0) {
+        console.log(ansiC.green(ansiC.inverse(`${runtime} > ${test}`)));
+    }
+    else if (failures > 0) {
+        console.log(ansiC.red(ansiC.inverse(`${runtime} > ${test} failed ${failures} times (exit code: ${failures})`)));
+    }
+    else {
+        console.log(ansiC.red(ansiC.inverse(`${runtime} > ${test} crashed (exit code: -1)`)));
+    }
+};
+export async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        await fs.writeFileSync(filePath, data);
+    }
+    catch (error) {
+        console.error(`Error writing file: ${error}`);
+    }
+}
+export const filesHash = async (files, algorithm = "md5") => {
+    return new Promise((resolve, reject) => {
+        resolve(files.reduce(async (mm, f) => {
+            return (await mm) + (await fileHash(f));
+        }, Promise.resolve("")));
+    });
+};
+export function isValidUrl(string) {
+    try {
+        new URL(string);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+// Wait for file to exist, checks every 2 seconds by default
+export async function pollForFile(path, timeout = 2000) {
+    const intervalObj = setInterval(function () {
+        const file = path;
+        const fileExists = fs.existsSync(file);
+        if (fileExists) {
+            clearInterval(intervalObj);
+        }
+    }, timeout);
+}
+const executablePath = "/opt/homebrew/bin/chromium";
+export const puppeteerConfigs = {
+    slowMo: 1,
+    waitForInitialPage: false,
+    executablePath,
+    headless: true,
+    defaultViewport: null, // Disable default 800x600 viewport
+    dumpio: false,
+    devtools: false,
+    args: [
+        "--allow-file-access-from-files",
+        "--allow-insecure-localhost",
+        "--allow-running-insecure-content",
+        "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-features=site-per-process",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        "--start-maximized",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        `--remote-debugging-port=3234`,
+        // "--disable-features=IsolateOrigins,site-per-process",
+        // "--disable-features=IsolateOrigins",
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--no-zygote",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--start-maximized",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+    ],
+};

package/dist/module/src/PM/web.js

@@ -16,12 +16,6 @@ export class PM_Web extends PM {
     pages() {
         throw new Error("Method not implemented.");
     }
-    stopSideCar(n) {
-        return window["stopSideCar"](n, this.testResourceConfiguration.name);
-    }
-    launchSideCar(n) {
-        return window["launchSideCar"](n, this.testResourceConfiguration.name);
-    }
     waitForSelector(p, s) {
         return window["waitForSelector"](p, s);
     }

package/dist/module/src/ReportServer.js

@@ -1,9 +1 @@
-import { ReportServerOfPort } from "./ReportServerLib";
-import { startDesignEditorServer } from "../design-editor/server";
-const port = process.argv[2] || 3000;
-const wssPort = Number(port) + 1; // Use next port for WebSocket
-// Start both servers
-ReportServerOfPort(port);
-startDesignEditorServer(wssPort);
-console.log(`Report server running on http://localhost:${port}`);
-console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);
+"use strict";

package/dist/module/src/ReportServerLib.js

@@ -1,134 +1 @@
-// simple http server to preview reports
-import staticServer from "node-static";
-import http from "http";
-import path from "path";
-import fs from "fs";
-const fileServer = new staticServer.Server("./", {
-    cache: false,
-    headers: {
-        "Cache-Control": "no-cache, no-store, must-revalidate",
-        Pragma: "no-cache",
-        Expires: "0",
-    },
-});
-const server = http.createServer((req, res) => {
-    // Handle potential double responses
-    let responded = false;
-    const safeResponse = (handler) => {
-        if (responded)
-            return;
-        responded = true;
-        try {
-            handler();
-        }
-        catch (err) {
-            console.error("Error handling request:", err);
-            if (!res.headersSent) {
-                res.writeHead(500);
-            }
-            res.end("Internal Server Error");
-        }
-    };
-    req.on("error", (err) => {
-        console.error("Request error:", err);
-        safeResponse(() => {
-            if (!res.headersSent) {
-                res.writeHead(400);
-            }
-            res.end("Bad Request");
-        });
-    });
-    req.on("end", () => {
-        safeResponse(() => {
-            const filePath = path.join(process.cwd(), req.url || "");
-            // First check if file exists
-            fs.stat(filePath, (err, stats) => {
-                if (err || !stats.isFile()) {
-                    // Check if directory exists
-                    fs.stat(filePath, (dirErr, dirStats) => {
-                        if (!dirErr && dirStats.isDirectory()) {
-                            // Serve directory listing
-                            fs.readdir(filePath, (readErr, files) => {
-                                if (readErr) {
-                                    res.writeHead(500);
-                                    return res.end("Error reading directory");
-                                }
-                                res.writeHead(200, { "Content-Type": "text/html" });
-                                res.write(`
-                  <html>
-                    <head>
-                      <title>Directory Listing: ${req.url}</title>
-                      <style>
-                        body { font-family: sans-serif; margin: 2rem; }
-                        h1 { color: #333; }
-                        ul { list-style: none; padding: 0; }
-                        li { padding: 0.5rem; }
-                        li a { color: #0366d6; text-decoration: none; }
-                        li a:hover { text-decoration: underline; }
-                      </style>
-                    </head>
-                    <body>
-                      <h1>Directory: ${req.url}</h1>
-                      <ul>
-                        ${files
-                                    .map((file) => `
-                          <li>
-                            <a href="${path.join(req.url || "", file)}">
-                              ${file}${file.endsWith("/") ? "/" : ""}
-                            </a>
-                          </li>
-                        `)
-                                    .join("")}
-                      </ul>
-                    </body>
-                  </html>
-                `);
-                                res.end();
-                            });
-                        }
-                        else {
-                            // Neither file nor directory exists - send 404
-                            if (!res.headersSent) {
-                                res.writeHead(404, { "Content-Type": "text/plain" });
-                                res.end("File not found");
-                            }
-                        }
-                    });
-                    return;
-                }
-                // File exists - serve it through node-static
-                const serve = () => {
-                    fileServer.serve(req, res, (err) => {
-                        if (err && !res.headersSent) {
-                            res.writeHead(err.status || 500);
-                            res.end(err.message);
-                        }
-                    });
-                };
-                // Ensure we don't double-serve
-                if (!res.headersSent) {
-                    serve();
-                }
-            });
-        });
-    });
-    req.resume();
-});
-server.on("error", (err) => {
-    console.error("Server error:", err);
-});
-process.on("uncaughtException", (err) => {
-    console.error("Uncaught exception:", err);
-});
-const start = (port) => {
-    if (port) {
-        server.listen(port, () => {
-            console.log(`Server running on http://localhost:${port}`);
-            console.log("Serving files from:", process.cwd());
-        });
-    }
-    else {
-        console.log("you need to specify a port");
-    }
-};
-export const ReportServerOfPort = (port) => start(port);
+"use strict";

package/dist/module/src/components/pure/AppFrame.js

@@ -1,32 +1,74 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import React, { useState } from 'react';
-import { Container, Nav } from 'react-bootstrap';
+import React from 'react';
+import { Container, Nav, OverlayTrigger, Tooltip } from 'react-bootstrap';
 import { NavLink } from 'react-router-dom';
 import { useLocation } from 'react-router-dom';
+import { useWebSocket, useTutorialMode, useAuth } from '../../App';
 export const AppFrame = ({ children, title, rightContent }) => {
     const location = useLocation();
-    const [isExpanded, setIsExpanded] = useState(true);
-    return (React.createElement("div", { className: "d-flex min-vh-100", style: { backgroundColor: '#f8f9fa' } },
-        React.createElement("div", { className: "bg-light border-end d-flex flex-column", style: {
-                width: isExpanded ? '250px' : '60px',
-                minHeight: '100vh',
-                transition: 'width 0.3s ease'
-            }, onMouseEnter: () => setIsExpanded(true), onMouseLeave: () => setIsExpanded(false) },
-            React.createElement("div", { className: "p-3 border-bottom d-flex align-items-center justify-content-center" }, isExpanded ? (React.createElement("img", { src: "/logo.svg", alt: "Testeranto Logo", style: { width: '128px', height: '128px' } })) : (React.createElement("img", { src: "/logo.svg", alt: "Testeranto Logo", style: { width: '40px', height: '40px' } }))),
+    const { isConnected } = useWebSocket();
+    const { tutorialMode } = useTutorialMode();
+    const { isAuthenticated, logout } = useAuth();
+    return (React.createElement("div", { className: "d-flex min-vh-100" },
+        React.createElement("div", { className: "border-end d-flex flex-column", style: {
+                width: '60px',
+                height: '100vh',
+                position: 'sticky',
+                top: 0
+            } },
+            tutorialMode ? (React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "logo-tooltip" }, "Welcome to Testeranto!") },
+                React.createElement("div", { className: "p-3 border-bottom d-flex align-items-center justify-content-center" },
+                    React.createElement("img", { src: "/logo.svg", alt: "Testeranto Logo", style: {
+                            width: '40px',
+                            height: '40px'
+                        } })))) : (React.createElement("div", { className: "p-3 border-bottom d-flex align-items-center justify-content-center" },
+                React.createElement("img", { src: "/logo.svg", alt: "Testeranto Logo", style: {
+                        width: '40px',
+                        height: '40px'
+                    } }))),
             React.createElement(Nav, { variant: "pills", className: "flex-column p-2 flex-grow-1" },
-                React.createElement(Nav.Link, { as: NavLink, to: "/", className: `${location.pathname === '/' ? 'active' : ''} text-truncate d-flex align-items-center`, style: { width: '100%' }, title: "Projects" },
-                    React.createElement("span", { className: "me-2" }, "\uD83D\uDCC1"),
-                    isExpanded && 'Projects'),
-                React.createElement(Nav.Link, { as: NavLink, to: "/processes", className: `${location.pathname.startsWith('/processes') ? 'active' : ''} text-truncate d-flex align-items-center`, style: { width: '100%' }, title: "Process Manager" },
-                    React.createElement("span", { className: "me-2" }, "\uD83D\uDCCA"),
-                    isExpanded && 'Process Manager'),
-                React.createElement(Nav.Link, { as: NavLink, to: "/settings", className: `${location.pathname === '/settings' ? 'active' : ''} text-truncate d-flex align-items-center`, style: { width: '100%' }, title: "Settings" },
-                    React.createElement("span", { className: "me-2" }, "\u2699\uFE0F"),
-                    isExpanded && 'Settings')),
-            React.createElement("div", { className: "p-3 border-top text-center mt-auto" }, isExpanded ? (React.createElement("small", { className: "text-muted" },
-                "made with \u2764\uFE0F and ",
-                React.createElement("a", { href: "https://www.npmjs.com/package/testeranto" }, "testeranto"))) : (React.createElement("small", { className: "text-muted" }, "\u2764\uFE0F")))),
-        React.createElement("div", { className: "flex-grow-1 d-flex flex-column" },
+                React.createElement(Nav.Link, { as: NavLink, to: "/", className: `${location.pathname === '/' ? 'active' : ''} d-flex align-items-center justify-content-center`, style: { height: '40px', width: '40px' } }, tutorialMode ? (React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "projects-tooltip" }, "Projects") },
+                    React.createElement("span", null, "\uD83D\uDCC1"))) : (React.createElement("span", null, "\uD83D\uDCC1"))),
+                React.createElement(Nav.Link, { as: NavLink, to: "/processes", className: `${location.pathname.startsWith('/processes') ? 'active' : ''} d-flex align-items-center justify-content-center ${!isConnected || !isAuthenticated ? 'text-muted pe-none' : ''}`, style: {
+                        height: '40px',
+                        width: '40px',
+                        opacity: isConnected && isAuthenticated ? 1 : 0.6
+                    }, onClick: (e) => {
+                        if (!isConnected || !isAuthenticated) {
+                            e.preventDefault();
+                        }
+                    } }, tutorialMode ? (React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "processes-tooltip" },
+                        "Processes ",
+                        !isAuthenticated ? '(Sign in required)' : !isConnected ? '(WebSocket disconnected)' : '') },
+                    React.createElement("span", null, "\uD83D\uDCCA"))) : (React.createElement("span", null, "\uD83D\uDCCA"))),
+                React.createElement(Nav.Link, { as: NavLink, to: "/git", className: `${location.pathname === '/git' ? 'active' : ''} d-flex align-items-center justify-content-center ${!isAuthenticated ? 'text-muted pe-none' : ''}`, style: {
+                        height: '40px',
+                        width: '40px',
+                        opacity: isAuthenticated ? 1 : 0.6
+                    }, onClick: (e) => {
+                        if (!isAuthenticated) {
+                            e.preventDefault();
+                        }
+                    } }, tutorialMode ? (React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "git-tooltip" },
+                        "Git Integration ",
+                        !isAuthenticated ? '(Sign in required)' : '') },
+                    React.createElement("span", null, "\uD83D\uDC19"))) : (React.createElement("span", null, "\uD83D\uDC19"))),
+                React.createElement(Nav.Link, { as: NavLink, to: "/settings", className: `${location.pathname === '/settings' ? 'active' : ''} d-flex align-items-center justify-content-center`, style: { height: '40px', width: '40px' } }, tutorialMode ? (React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "settings-tooltip" }, "Settings") },
+                    React.createElement("span", null, "\u2699\uFE0F"))) : (React.createElement("span", null, "\u2699\uFE0F")))),
+            React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "status-tooltip" }, isConnected ? 'Dev mode - Full access' : 'Static mode - Read only') },
+                React.createElement("div", { className: "p-2 border-top d-flex align-items-center justify-content-center" },
+                    React.createElement("span", { className: `badge rounded-circle d-flex align-items-center justify-content-center`, style: {
+                            backgroundColor: isConnected ? '#198754' : '#6c757d',
+                            width: '20px',
+                            height: '20px',
+                            fontSize: '12px'
+                        } }, isConnected ? '🟢' : '🔴'))),
+            React.createElement(OverlayTrigger, { placement: "right", overlay: React.createElement(Tooltip, { id: "footer-tooltip" },
+                    "made with \u2764\uFE0F and ",
+                    React.createElement("a", { href: "https://www.npmjs.com/package/testeranto" }, "testeranto")) },
+                React.createElement("div", { className: "p-3 border-top text-center mt-auto" },
+                    React.createElement("span", { className: "text-muted" }, "\u2764\uFE0F")))),
+        React.createElement("div", { className: "flex-grow-1 d-flex flex-column", style: { minHeight: '100vh' } },
             React.createElement("main", { className: "flex-grow-1 p-4", style: { overflow: 'auto' } },
-                React.createElement(Container, { fluid: true, className: "h-100" }, children)))));
+                React.createElement(Container, { fluid: true, style: { height: '100%' } }, children)))));
 };