samengine-build 1.6.3

package/README.md

@@ -0,0 +1,5 @@
+# Samengine Build
+
+The build and export Tool for samengine.
+
+Check samengine on [Github](https://github.com/ShadowDara/samengine) or [NPM](https://www.npmjs.com/package/samengine).

package/dist/buildconfig.d.ts

@@ -0,0 +1,9 @@
+export interface buildconfig {
+    htmlhead: string;
+    title: string;
+    version: string;
+    show_fullscreen_button: boolean;
+    entryname: string;
+    outdir: string;
+}
+export declare function new_buildconfig(): buildconfig;

package/dist/buildconfig.js

@@ -0,0 +1,11 @@
+// Generate the HTML File
+export function new_buildconfig() {
+    return {
+        htmlhead: "",
+        title: "My new Game",
+        version: "0.0.0",
+        show_fullscreen_button: true,
+        entryname: "main",
+        outdir: "dist",
+    };
+}

package/dist/buildhelper.d.ts

@@ -0,0 +1,6 @@
+export declare const flog: (...args: any[]) => void;
+export declare function copyFolder(src: string, dest: string): Promise<void>;
+export declare function scanResourcesAsDataURIs(resourceDir: string): Promise<Record<string, string>>;
+export declare function getContentType(path: string): string;
+export declare function getMimeType(filename: string): string;
+export declare function filterResourcesByUsage(bundledJsContent: string, resourcesMap: Record<string, string>): Record<string, string>;

package/dist/buildhelper.js

@@ -0,0 +1,108 @@
+import { readdirSync, mkdirSync, promises as fsPromises, existsSync } from "fs";
+import { join } from "path";
+export const flog = (...args) => {
+    const now = new Date();
+    const time = `[${now.getHours().toString().padStart(2, "0")}:` +
+        `${now.getMinutes().toString().padStart(2, "0")}:` +
+        `${now.getSeconds().toString().padStart(2, "0")}.` +
+        `${now.getMilliseconds().toString().padStart(3, "0")}]`;
+    console.log(time, ...args);
+};
+export async function copyFolder(src, dest) {
+    // Zielordner erstellen
+    mkdirSync(dest, { recursive: true });
+    const entries = readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyFolder(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            // Datei mit Node.js schreiben
+            const data = await fsPromises.readFile(srcPath);
+            await fsPromises.writeFile(destPath, data);
+        }
+    }
+}
+// Scan resources folder and convert to data URIs (base64)
+export async function scanResourcesAsDataURIs(resourceDir) {
+    const resourceMap = {};
+    if (!existsSync(resourceDir)) {
+        return resourceMap;
+    }
+    async function scanDir(dir, basePath = "") {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            const resourcePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await scanDir(fullPath, resourcePath);
+            }
+            else if (entry.isFile()) {
+                const fileData = await fsPromises.readFile(fullPath);
+                const base64Data = fileData.toString("base64");
+                const mimeType = getMimeType(entry.name);
+                resourceMap[resourcePath] = `data:${mimeType};base64,${base64Data}`;
+            }
+        }
+    }
+    await scanDir(resourceDir);
+    return resourceMap;
+}
+// === Helper ===
+export function getContentType(path) {
+    if (path.endsWith(".js"))
+        return "application/javascript";
+    if (path.endsWith(".ts"))
+        return "application/typescript";
+    if (path.endsWith(".html"))
+        return "text/html";
+    if (path.endsWith(".css"))
+        return "text/css";
+    if (path.endsWith(".png"))
+        return "image/png";
+    return "text/plain";
+}
+export function getMimeType(filename) {
+    const ext = filename.toLowerCase().split(".").pop() || "";
+    const mimeTypes = {
+        "png": "image/png",
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "gif": "image/gif",
+        "svg": "image/svg+xml",
+        "webp": "image/webp",
+        "mp3": "audio/mpeg",
+        "wav": "audio/wav",
+        "ogg": "audio/ogg",
+        "m4a": "audio/mp4",
+        "json": "application/json",
+        "txt": "text/plain",
+        "css": "text/css",
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+}
+// Filter resources by checking if they are actually used in the bundled code
+export function filterResourcesByUsage(bundledJsContent, resourcesMap) {
+    const filteredResources = {};
+    const unusedResources = [];
+    for (const resourcePath in resourcesMap) {
+        // Extract just the filename (last part after /)
+        const filename = resourcePath.split("/").pop() || resourcePath;
+        // Check if the resource is referenced in the bundled code
+        // Look for string literals containing the resource path or filename
+        if (bundledJsContent.includes(filename) || bundledJsContent.includes(resourcePath)) {
+            filteredResources[resourcePath] = resourcesMap[resourcePath];
+        }
+        else {
+            unusedResources.push(resourcePath);
+        }
+    }
+    // Log unused resources
+    if (unusedResources.length > 0) {
+        flog(`⚠️  ${unusedResources.length} unused resource(s) excluded from single-file build:`);
+        unusedResources.forEach(res => flog(`   - ${res}`));
+    }
+    return filteredResources;
+}

package/dist/cli/argparser.d.ts

@@ -0,0 +1,8 @@
+export interface CLIArgs {
+    release: boolean;
+    singlefile: boolean;
+    port: number;
+    newProject: string | null;
+    empty: boolean;
+}
+export declare function parseArgs(): CLIArgs;

package/dist/cli/argparser.js

@@ -0,0 +1,36 @@
+// Arguments for the CLI Tool
+// Function to parse the Args for the CLI Tools
+export function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = { release: false, singlefile: false, port: 3000, newProject: null, empty: false };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case "--single-file":
+                options.singlefile = true;
+                break;
+            case "--release":
+            case "-r":
+                options.release = true;
+                break;
+            case "--port":
+            case "-p":
+                options.port = Number(args[++i]);
+                break;
+            case "--new":
+            case "-n":
+                options.newProject = args[++i];
+                break;
+            case "--new-empty":
+                options.empty = true;
+                break;
+            case "-h":
+            case "--help":
+                console.log("CLI Tools for samengine\nUsage:\n  -r, --release\n  -p <port>\n  -n <project>\n  --new-empty\n --single-file   to generate the Export into one file");
+                process.exit(0);
+            default:
+                console.warn(`⚠️ Unknown Argument: ${arg}`);
+        }
+    }
+    return options;
+}

package/dist/cli/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Build Cli Tools for samengine
+import { build as esbuild } from "esbuild";
+import { createServer } from "http";
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { watch } from "fs";
+import path from "path";
+import { WebSocketServer } from "ws";
+import { createProject } from "./new.js";
+import { copyFolder, flog, getContentType, scanResourcesAsDataURIs, filterResourcesByUsage } from "../buildhelper.js";
+import { GetDefaultHTML, GetSingleFileHTML } from "../exporthtml.js";
+import { loadUserConfig } from "./config.js";
+import { compressHTML } from "../utils/utils.js";
+import { parseArgs } from "./argparser.js";
+// ================= BUILD =================
+function createBuilder(config, isRelease, isSingleFile = false) {
+    // Ensure that the Directories are created
+    mkdir("resources", { recursive: true });
+    mkdir("game", { recursive: true });
+    async function build() {
+        try {
+            flog("🔄 Building project...");
+            if (isRelease)
+                await rm("./dist", { recursive: true, force: true });
+            await esbuild({
+                entryPoints: [`./game/${config.entryname}`],
+                outdir: `./${config.outdir}`,
+                bundle: true,
+                platform: "browser",
+                minify: isRelease,
+                sourcemap: !isRelease,
+                define: { "import.meta.env.DEV": JSON.stringify(!isRelease) },
+            });
+            if (isSingleFile) {
+                // Single-file export
+                const bundledJsPath = path.join(".", config.outdir, `${config.entryname.replace(/\.[^.]*$/, "")}.js`);
+                const bundledJsContent = await readFile(bundledJsPath, "utf-8");
+                // Scan resources and convert to data URIs
+                let resourcesMap = await scanResourcesAsDataURIs("./resources");
+                // Filter resources by usage in the bundled code
+                resourcesMap = filterResourcesByUsage(bundledJsContent, resourcesMap);
+                let html = GetSingleFileHTML(config, bundledJsContent, resourcesMap);
+                if (isRelease)
+                    html = await compressHTML(html);
+                // Add comment at the beginning after minification
+                const htmlComment = `<!-- Game made with samengine v${config.version} - https://github.com/Shadowdara/samengine -->\n`;
+                html = htmlComment + html;
+                await writeFile("./dist/index.html", html);
+                // Delete the JS File
+                await rm("./dist/main.js", { recursive: true, force: true });
+                flog("✅ Single-file export created!");
+            }
+            else {
+                // Multi-file export (original behavior)
+                let html = GetDefaultHTML(config);
+                if (isRelease)
+                    html = await compressHTML(html);
+                // Add HTML comment at the beginning after minification
+                const htmlComment = `<!-- Game made with samengine v${config.version} - https://www.npmjs.com/@shadowdara/samengine -->\n`;
+                html = htmlComment + html;
+                await writeFile("./dist/index.html", html);
+                // Add JS comment at the beginning of JS files
+                const jsComment = `// Game made with samengine v${config.version} - https://www.npmjs.com/@shadowdara/samengine\n`;
+                const jsPath = path.join(".", config.outdir, `${config.entryname.replace(/\.[^.]*$/, "")}.js`);
+                let jsContent = await readFile(jsPath, "utf-8");
+                jsContent = jsComment + jsContent;
+                await writeFile(jsPath, jsContent);
+                await copyFolder("./resources", "./dist/resources");
+                flog("✅ Build finished!");
+            }
+        }
+        catch (error) {
+            flog(`❌ Build failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { build };
+}
+// ================= SERVER & RELOAD =================
+function createDevServer(port) {
+    const sockets = new Set(); // <-- ws WebSocket, nicht DOM
+    const server = createServer(async (req, res) => {
+        const url = req.url || "/";
+        const filePath = path.join(process.cwd(), "dist", url === "/" ? "index.html" : url);
+        try {
+            const file = await readFile(filePath);
+            res.writeHead(200, { "Content-Type": getContentType(filePath) });
+            res.end(file);
+        }
+        catch {
+            res.writeHead(404);
+            res.end("Not Found");
+        }
+    });
+    const wss = new WebSocketServer({ server });
+    wss.on("connection", (ws) => {
+        sockets.add(ws);
+        ws.on("close", () => sockets.delete(ws));
+    });
+    server.listen(port, () => flog(`🚀 Dev Server running on http://localhost:${port}`));
+    function reloadClients() {
+        flog("🔄 Browser reload...");
+        sockets.forEach((ws) => ws.send("reload"));
+    }
+    return { reloadClients };
+}
+// ================= WATCHER =================
+async function startWatcher(onChange) {
+    await mkdir("resources", { recursive: true });
+    await mkdir("game", { recursive: true });
+    ["resources", "game"].forEach((dir) => {
+        watch(dir, { recursive: true }, async () => {
+            flog(`📁 Change noticed in ${dir}`);
+            await onChange();
+        });
+    });
+    flog("👀 Watcher active...");
+}
+// ================= CLI APP =================
+async function main() {
+    const args = parseArgs();
+    if (args.newProject) {
+        await createProject(args.newProject, args.empty);
+        process.exit(0);
+    }
+    const config = await loadUserConfig();
+    const builder = createBuilder(config, args.release, args.singlefile);
+    let isBuilding = false;
+    let pendingRestart = false;
+    async function restart() {
+        if (isBuilding) {
+            pendingRestart = true;
+            return;
+        }
+        isBuilding = true;
+        do {
+            pendingRestart = false;
+            try {
+                await builder.build();
+                devServer?.reloadClients();
+            }
+            catch (error) {
+                flog(`❌ Rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        } while (pendingRestart);
+        isBuilding = false;
+    }
+    try {
+        await builder.build();
+    }
+    catch (error) {
+        flog(`❌ Initial build failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let devServer = null;
+    if (!args.release) {
+        devServer = createDevServer(args.port);
+        await startWatcher(restart);
+    }
+    flog(`Build finished! Mode: ${args.release ? "Release" : "Dev"}`);
+}
+main();

package/dist/cli/config.d.ts

@@ -0,0 +1 @@
+export declare function loadUserConfig(): Promise<any>;

package/dist/cli/config.js

@@ -0,0 +1,32 @@
+import { build } from "esbuild";
+import path from "path";
+import { pathToFileURL } from "url";
+import fs from "fs/promises";
+export async function loadUserConfig() {
+    const root = process.cwd();
+    const configPath = path.resolve(root, "samengine.config.ts");
+    const outDir = path.resolve(root, ".samengine");
+    const outfile = path.join(outDir, "config.mjs");
+    try {
+        // ensure folder exists
+        await fs.mkdir(outDir, { recursive: true });
+        // 🔥 bundle TS → JS
+        await build({
+            entryPoints: [configPath],
+            outfile,
+            bundle: true,
+            platform: "node",
+            format: "esm",
+        });
+        // 🔥 import compiled file
+        const mod = await import(pathToFileURL(outfile).href + `?t=${Date.now()}`);
+        const config = typeof mod.default === "function"
+            ? await mod.default()
+            : mod.default;
+        return config;
+    }
+    catch (e) {
+        console.error(e);
+        throw new Error("❌ Could not load webgameengine.config.ts: " + configPath);
+    }
+}

package/dist/cli/new.d.ts

@@ -0,0 +1 @@
+export declare function createProject(name: string, empty: boolean): Promise<void>;

package/dist/cli/new.js

@@ -0,0 +1,198 @@
+import path from "path";
+import { writeFile, mkdir } from "fs/promises";
+import chalk from 'chalk';
+import { flog } from "../buildhelper.js";
+// ================= NEW PROJECT =================
+export async function createProject(name, empty) {
+    flog(`📦 Erstelle neues Projekt: ${name}`);
+    // Create Dirs
+    await mkdir("game", { recursive: true });
+    await mkdir("resources", { recursive: true });
+    await mkdir("dist", { recursive: true });
+    let content = `
+// A empty Project with the Web Framework
+
+import { createCanvas, enableFullscreen, setupFullscreenButton } from "samengine";
+import { setupInput, resetInput, getMouse } from "samengine";
+import { startEngine } from "samengine";
+
+const { canvas, ctx, applyScaling } = createCanvas({fullscreen: true, scaling: "fit", virtualWidth: window.innerWidth, virtualHeight: window.innerHeight});
+setupInput(canvas);
+
+enableFullscreen(canvas);
+setupFullscreenButton(canvas);
+
+async function gameStart() {
+    // Code which runs at the Game Start
+}
+
+function gameLoop(dt: number) {
+    // Code which runs every Frame
+
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    const mouse = getMouse();
+
+    applyScaling();
+
+    resetInput();
+}
+
+// Because start Game is Async
+startEngine(() => { gameStart().then(() => {/* ready */}) }, gameLoop);
+`;
+    if (empty) {
+        content = `
+// A mini Snake Clone with my Webframework
+
+import { createCanvas } from "samengine";
+import { setupInput, isKeyJustPressed, resetInput } from "samengine";
+import { startEngine } from "samengine";
+import { renderText } from "samengine";
+import { Vector2d } from "samengine/types";
+import { dlog } from "samengine";
+import { Key } from "samengine";
+
+const { canvas, ctx } = createCanvas({fullscreen: true, scaling: "fit", virtualWidth: window.innerWidth, virtualHeight: window.innerHeight});
+setupInput(canvas);
+
+let snake: Vector2d[] = [{ x: 10, y: 10 }];
+let dir: Vector2d = { x: 1, y: 0 };
+let food: Vector2d = { x: 15, y: 10 };
+let gridSize = 20;
+let lastMove = 0;
+let speed = 0.2; // seconds per cell
+let start = false;
+
+async function gameStart() {
+    dlog("Snake gestartet");
+}
+
+function gameLoop(dt: number) {
+    if (isKeyJustPressed(Key.Escape)) {
+        start = !start
+    }
+
+    if (!start) {
+        ctx.fillStyle = "white";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+        renderText(ctx, "Snake", 10, 10, "black", "24px Arial");
+        renderText(ctx, "Press ESC to start or Pause the Game!", 10, 50, "black", "24px Arial");
+
+        // return;
+    } else {
+
+        // Input
+        if (isKeyJustPressed(Key.ArrowUp) && dir.y === 0) dir = { x: 0, y: -1 };
+        if (isKeyJustPressed(Key.ArrowDown) && dir.y === 0) dir = { x: 0, y: 1 };
+        if (isKeyJustPressed(Key.ArrowLeft) && dir.x === 0) dir = { x: -1, y: 0 };
+        if (isKeyJustPressed(Key.ArrowRight) && dir.x === 0) dir = { x: 1, y: 0 };
+
+        lastMove += dt;
+
+        if (lastMove >= speed) {
+            lastMove = 0;
+            const head = { x: snake[0].x + dir.x, y: snake[0].y + dir.y };
+
+            // Kollision mit Walls
+            if (head.x < 0 || head.y < 0 || head.x >= canvas.width / gridSize || head.y >= canvas.height / gridSize) {
+                snake = [{ x: 10, y: 10 }];
+                dir = { x: 1, y: 0 };
+                dlog("Game Over");
+                return;
+            }
+
+            // Kollision mit sich selbst
+            if (snake.some(s => s.x === head.x && s.y === head.y)) {
+                snake = [{ x: 10, y: 10 }];
+                dir = { x: 1, y: 0 };
+                dlog(\`Game Over! Highscore: \${snake.length - 1}\`);
+                return;
+            }
+
+            snake.unshift(head);
+
+            // Food Check
+            if (head.x === food.x && head.y === food.y) {
+                food = { x: Math.floor(Math.random() * (canvas.width / gridSize)), y: Math.floor(Math.random() * (canvas.height / gridSize)) };
+            } else {
+                snake.pop();
+            }
+        }
+
+        // Zeichnen
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+        ctx.fillStyle = "black";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+        ctx.fillStyle = "green";
+        snake.forEach(s => ctx.fillRect(s.x * gridSize, s.y * gridSize, gridSize, gridSize));
+
+        ctx.fillStyle = "red";
+        ctx.fillRect(food.x * gridSize, food.y * gridSize, gridSize, gridSize);
+
+        renderText(ctx, "Score: " + (snake.length - 1), 10, 10, "yellow", "24px Arial");
+
+    }
+
+    // Reset Input
+    resetInput();
+}
+
+// Because start Game is Async
+startEngine(() => { gameStart().then(() => {/* ready */}) }, gameLoop);
+`;
+    }
+    // Basic game entry
+    await writeFile(path.join("game", "main.ts"), content);
+    // Config
+    await writeFile(path.join("samengine.config.ts"), `
+// Project File for the Game
+
+import type { buildconfig } from "samengine-build";
+import { new_buildconfig } from "samengine-build";
+
+export default function defineConfig(): buildconfig {
+    let config: buildconfig = new_buildconfig();
+    return config;
+}
+`);
+    // package.json
+    // await writeFile(
+    //     path.join(base, "package.json"),
+    //     JSON.stringify(
+    //         {
+    //             name,
+    //             version: "1.0.0",
+    //             type: "module",
+    //             scripts: {
+    //                 dev: "mycli",
+    //                 build: "mycli --release",
+    //             },
+    //         },
+    //         null,
+    //         2
+    //     )
+    // );
+    flog("✅ Projekt created!");
+    // flog(`👉 cd ${name}`);
+    // flog(`👉 npm install`);
+    // flog(`👉 npm run dev`);
+    console.log(`Add to your package.json file:
+
+  "scripts": {
+    "dev": "npx samengine-build",
+    "build": "npx samengine-build --release"
+  },
+
+Run "npm run dev" to start the Dev Server and play a little Snake Clone
+
+Add ".samengine/config.mjs" to your gitignore file if you are using Git.
+
+${chalk.red("Dont ignore the complete Folder!")}
+${chalk.red("Some Tools by samengine are saving important configs in this Folder!")}
+`);
+    process.exit(0);
+}

package/dist/exporthtml.d.ts

@@ -0,0 +1,3 @@
+import type { buildconfig } from "./buildconfig.js";
+export declare function GetSingleFileHTML(config: buildconfig, bundledJsContent: string, resourcesMap?: Record<string, string>): string;
+export declare function GetDefaultHTML(config: buildconfig): string;

package/dist/exporthtml.js

@@ -0,0 +1,279 @@
+// Function to create the Export HTML for the Build
+// Function to create the Export HTML for the Build
+import { version } from "samengine/build";
+export function GetSingleFileHTML(config, bundledJsContent, resourcesMap = {}) {
+    let frameworkVersion = version();
+    let fullscreenbutton = "";
+    let fullscreenBtn = "";
+    if (config.show_fullscreen_button) {
+        fullscreenbutton = `#fullscreenBtn {
+    position: fixed;
+    top: 10px;
+    right: 10px;
+
+    padding: 10px 15px;
+    font-size: 16px;
+
+    background: rgba(0, 0, 0, 0.6);
+    color: white;
+    border: none;
+    border-radius: 6px;
+
+    cursor: pointer;
+    z-index: 1000;
+}
+
+#fullscreenBtn:hover {
+    background: rgba(0, 0, 0, 0.8);
+}`;
+        fullscreenBtn = `<!-- Button to make it fullscreen -->
+<button id="fullscreenBtn">⛶ Fullscreen</button>`;
+    }
+    // Create a resource loader function that will be embedded in the HTML
+    const resourceLoaderScript = `window.__resources = ${JSON.stringify(resourcesMap)};
+window.__getResource = function(path) {
+    return window.__resources[path] || null;
+};
+window.__loadResource = function(path) {
+    const resource = window.__getResource(path);
+    if (!resource) {
+        console.warn('Resource not found:', path);
+        return null;
+    }
+    return resource;
+};
+window.__samengine__ = {
+    version: "${frameworkVersion}"
+};`;
+    // Wrap bundled JS in a function to prevent auto-execution
+    const wrappedGameCode = `function __initializeGame() {
+${bundledJsContent.split('\n').map(line => '  ' + line).join('\n')}
+}`;
+    const defaulthtml = `<!-- HTML Web Game made with samengine by Shadowdara -->
+<!-- DO NOT REMOVE THIS NOTE ! -->    
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>${config.title}</title>
+    <!-- Für Mobile Viewports -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      body {
+        overflow: hidden; /* 🔥 verhindert Scrollbars */
+      }
+body {
+    margin: 0;
+    background: #0f172a;
+    color: white;
+    font-family: sans-serif;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100vh;
+}
+
+#startscreen {
+    text-align: center;
+}
+
+h1 {
+    font-size: 3rem;
+    margin-bottom: 0.5rem;
+}
+
+h2 {
+    font-weight: normal;
+    opacity: 0.7;
+}
+
+.startbutton {
+    margin-top: 2rem;
+    padding: 1rem 2rem;
+    font-size: 1.2rem;
+    background: #22c55e;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+}
+
+.startbutton:hover {
+    background: #16a34a;
+}
+${fullscreenbutton}
+</style>
+    </style>
+  </head>
+  <body>
+  <div id="startscreen">
+        <h2>made with samengine</h2>
+        <h1>${config.title}</h1>
+        <p>${config.version}</p>
+
+        <button class="startbutton" id="startBtn">Start</button>
+    </div>
+
+    <script>
+        ${resourceLoaderScript}
+    </script>
+    <script>
+        ${wrappedGameCode}
+    </script>
+    <script type="module">
+        const btn = document.getElementById("startBtn");
+
+        btn.addEventListener("click", async () => {
+            // 🔊 Audio freischalten
+            const AudioContext = window.AudioContext || window.webkitAudioContext;
+            
+            const ctx = new AudioContext();
+            await ctx.resume();
+
+            // 👉 HIER rein!
+            window.__audioCtx = ctx;
+
+            // Startscreen entfernen
+            document.getElementById("startscreen").remove();
+
+            // Initialize the game
+            window.__initializeGame();
+        });
+    </script>
+    ${fullscreenBtn}
+  </body>
+</html>
+`;
+    return defaulthtml;
+}
+export function GetDefaultHTML(config) {
+    let frameworkVersion = version();
+    let fullscreenbutton = "";
+    let fullscreenBtn = "";
+    if (config.show_fullscreen_button) {
+        fullscreenbutton = `#fullscreenBtn {
+    position: fixed;
+    top: 10px;
+    right: 10px;
+
+    padding: 10px 15px;
+    font-size: 16px;
+
+    background: rgba(0, 0, 0, 0.6);
+    color: white;
+    border: none;
+    border-radius: 6px;
+
+    cursor: pointer;
+    z-index: 1000;
+}
+
+#fullscreenBtn:hover {
+    background: rgba(0, 0, 0, 0.8);
+}`;
+        fullscreenBtn = `<!-- Button to make it fullscreen -->
+<button id="fullscreenBtn">⛶ Fullscreen</button>`;
+    }
+    const defaulthtml = `<!-- HTML Web Game made with samengine by Shadowdara -->
+<!-- DO NOT REMOVE THIS NOTE ! -->    
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>${config.title}</title>
+    <!-- Für Mobile Viewports -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      body {
+        overflow: hidden; /* 🔥 verhindert Scrollbars */
+      }
+body {
+    margin: 0;
+    background: #0f172a;
+    color: white;
+    font-family: sans-serif;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    height: 100vh;
+}
+
+#startscreen {
+    text-align: center;
+}
+
+h1 {
+    font-size: 3rem;
+    margin-bottom: 0.5rem;
+}
+
+h2 {
+    font-weight: normal;
+    opacity: 0.7;
+}
+
+.startbutton {
+    margin-top: 2rem;
+    padding: 1rem 2rem;
+    font-size: 1.2rem;
+    background: #22c55e;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+}
+
+.startbutton:hover {
+    background: #16a34a;
+}
+${fullscreenbutton}
+</style>
+    </style>
+  </head>
+  <body>
+  <div id="startscreen">
+        <h2>made with samengine</h2>
+        <h1>${config.title}</h1>
+        <p>${config.version}</p>
+
+        <button class="startbutton" id="startBtn">Start</button>
+    </div>
+
+    <script type="module">
+        const btn = document.getElementById("startBtn");
+
+        btn.addEventListener("click", async () => {
+            // 🔊 Audio freischalten
+            const AudioContext = window.AudioContext || window.webkitAudioContext;
+            
+            const ctx = new AudioContext();
+            await ctx.resume();
+
+            // 👉 HIER rein!
+            window.__audioCtx = ctx;
+
+            // Startscreen entfernen
+            document.getElementById("startscreen").remove();
+
+            // Game laden
+            import("./${config.entryname}.js");
+        });
+
+        window.__samengine__ = {
+            version: "${frameworkVersion}"
+        };
+    </script>
+    ${fullscreenBtn}
+  </body>
+</html>
+`;
+    return defaulthtml;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { buildconfig } from "./buildconfig.js";
+export { new_buildconfig } from "./buildconfig.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { new_buildconfig } from "./buildconfig.js";

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export { compressHTML } from "./utils.js";

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+// Build Utils
+export { compressHTML } from "./utils.js";

package/dist/utils/utils.d.ts

@@ -0,0 +1 @@
+export declare function compressHTML(html: string): Promise<string>;

package/dist/utils/utils.js

@@ -0,0 +1,12 @@
+import { minify } from "html-minifier-terser";
+// Function to compress HTML
+export async function compressHTML(html) {
+    return await minify(html, {
+        collapseWhitespace: true,
+        removeComments: true,
+        removeRedundantAttributes: true,
+        removeEmptyAttributes: true,
+        minifyCSS: true,
+        minifyJS: true,
+    });
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "samengine-build",
+  "version": "1.6.3",
+  "description": "The build and export Tool for samengine.",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "pack": "node ../scripts/clean.js && npm run build && npm pack && git push --follow-tags && node ../scripts/checkversion.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./utils": "./dist/utils/index.js"
+  },
+  "bin": {
+    "samengine-build": "dist/cli/cli.js"
+  },
+  "author": "Shadowdara",
+  "type": "module",
+  "devDependencies": {
+    "@types/html-minifier-terser": "^7.0.2",
+    "@types/node": "^25.5.2",
+    "@types/ws": "^8.18.1",
+    "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "esbuild": "^0.28.0",
+    "html-minifier-terser": "^7.2.0",
+    "mime": "^4.1.0",
+    "samengine": "^1.6.3",
+    "ws": "^8.20.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shadowdara/samengine"
+  },
+  "bugs": {
+    "url": "https://github.com/shadowdara/samengine/issues"
+  }
+}