@hotbunny/hackhub-content-sdk 0.5.1 → 0.6.0

package/build.mjs

@@ -1,6 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
 
+const ASSET_EXTS = /\.(png|jpg|jpeg|gif|svg|ico|webp|css|js|cur|woff|woff2|ttf|eot|mp3|wav|ogg|mp4|webm|json|pdf)$/i;
+const SRC_ASSET_PATTERN = /["'](\.[^"']+?\.(png|jpg|jpeg|gif|svg|ico|webp|css|js|cur|woff|woff2|ttf|eot|mp3|wav|ogg|mp4|webm|json|pdf))["']/gi;
+
+// ─── SDK project schema version ─────────────────────────────────────
+// Bump this when the required project structure changes (new files,
+// new manifest fields, tsconfig options, etc.). buildMod() compares
+// it against the project's saved version and runs migrations.
+const PROJECT_SCHEMA_VERSION = 1;
+
 function copyDirSync(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
     for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
@@ -24,10 +33,151 @@ function prepareDist() {
     }
 }
 
+function collectFilesRecursive(dir, ext, results = []) {
+    if (!fs.existsSync(dir)) return results;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectFilesRecursive(full, ext, results);
+        } else if (ext.some(e => entry.name.endsWith(e))) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+
+function scanSourceAssets() {
+    const sourceFiles = collectFilesRecursive("src", [".ts", ".tsx"]);
+    let copied = 0;
+
+    for (const file of sourceFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const fileDir = path.dirname(file);
+        let match;
+        SRC_ASSET_PATTERN.lastIndex = 0;
+
+        while ((match = SRC_ASSET_PATTERN.exec(content)) !== null) {
+            const ref = match[1];
+            const absPath = path.resolve(fileDir, ref);
+            if (fs.existsSync(absPath)) {
+                const rel = ref.startsWith("./") ? ref.slice(2) : ref;
+                const dest = path.join("dist", rel);
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                fs.copyFileSync(absPath, dest);
+                copied++;
+            }
+        }
+    }
+
+    return copied;
+}
+
+// ─── Required file templates ────────────────────────────────────────
+// Each entry defines a file that must exist in the mod project.
+// If missing, it's auto-created from the template.
+
+const REQUIRED_FILES = {
+    "src/types.d.ts": {
+        content: `declare module "*.html" {\n    const value: string;\n    export default value;\n}\n`,
+        description: "HTML import type declarations",
+    },
+};
+
+// Fields that must exist in manifest.json (with defaults)
+const REQUIRED_MANIFEST_FIELDS = {
+    apiVersion: "1.0",
+};
+
+// Required tsconfig.json compilerOptions
+const REQUIRED_TSCONFIG_OPTIONS = {
+    experimentalDecorators: true,
+    strict: true,
+};
+
 /**
- * esbuild plugin: scans HTML files for local asset references
- * (script src, link href, img src) and copies them into dist/.
+ * Validates project structure and auto-fixes missing/outdated files.
+ * Returns a list of actions taken.
  */
+function validateProject() {
+    const actions = [];
+
+    // 1. Check required files
+    for (const [filePath, spec] of Object.entries(REQUIRED_FILES)) {
+        if (!fs.existsSync(filePath)) {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, spec.content, "utf-8");
+            actions.push(`Created missing file: ${filePath} (${spec.description})`);
+        }
+    }
+
+    // 2. Check manifest.json required fields
+    if (fs.existsSync("manifest.json")) {
+        const raw = fs.readFileSync("manifest.json", "utf-8");
+        const manifest = JSON.parse(raw);
+        let changed = false;
+
+        for (const [key, defaultValue] of Object.entries(REQUIRED_MANIFEST_FIELDS)) {
+            if (!(key in manifest)) {
+                manifest[key] = defaultValue;
+                changed = true;
+                actions.push(`Added missing manifest field: "${key}" = "${defaultValue}"`);
+            }
+        }
+
+        if (changed) {
+            fs.writeFileSync("manifest.json", JSON.stringify(manifest, null, 4) + "\n", "utf-8");
+        }
+    } else {
+        actions.push("WARNING: manifest.json not found!");
+    }
+
+    // 3. Check tsconfig.json required options
+    if (fs.existsSync("tsconfig.json")) {
+        const raw = fs.readFileSync("tsconfig.json", "utf-8");
+        let tsconfig;
+        try {
+            tsconfig = JSON.parse(raw);
+        } catch {
+            actions.push("WARNING: tsconfig.json has invalid JSON");
+            return actions;
+        }
+
+        if (!tsconfig.compilerOptions) tsconfig.compilerOptions = {};
+        let changed = false;
+
+        for (const [key, value] of Object.entries(REQUIRED_TSCONFIG_OPTIONS)) {
+            if (tsconfig.compilerOptions[key] !== value) {
+                tsconfig.compilerOptions[key] = value;
+                changed = true;
+                actions.push(`Fixed tsconfig option: "${key}" → ${value}`);
+            }
+        }
+
+        if (changed) {
+            fs.writeFileSync("tsconfig.json", JSON.stringify(tsconfig, null, 4) + "\n", "utf-8");
+        }
+    }
+
+    // 4. Check public/ directory exists
+    if (!fs.existsSync("public")) {
+        fs.mkdirSync("public", { recursive: true });
+        actions.push("Created missing public/ directory");
+    }
+
+    // 5. Update schema version stamp
+    const stampFile = "node_modules/.hackhub-schema-version";
+    const currentStamp = fs.existsSync(stampFile) ? parseInt(fs.readFileSync(stampFile, "utf-8").trim(), 10) : 0;
+    if (currentStamp < PROJECT_SCHEMA_VERSION) {
+        fs.mkdirSync(path.dirname(stampFile), { recursive: true });
+        fs.writeFileSync(stampFile, String(PROJECT_SCHEMA_VERSION), "utf-8");
+        if (currentStamp > 0) {
+            actions.push(`Project schema updated: v${currentStamp} → v${PROJECT_SCHEMA_VERSION}`);
+        }
+    }
+
+    return actions;
+}
+
 export function htmlAssetsPlugin() {
     const assetPattern = /(?:src|href)\s*=\s*["'](\.[^"']+)["']/g;
 
@@ -58,9 +208,12 @@ export function htmlAssetsPlugin() {
     };
 }
 
+function log(msg) { process.stdout.write(`\x1b[36m[HackHub]\x1b[0m ${msg}\n`); }
+function logSuccess(msg) { process.stdout.write(`\x1b[32m[HackHub]\x1b[0m ${msg}\n`); }
+function logWarn(msg) { process.stdout.write(`\x1b[33m[HackHub]\x1b[0m ${msg}\n`); }
+
 /**
  * Builds a HackHub mod project.
- * Call this from your esbuild.config.ts — all build logic is handled here.
  *
  * @param {object} [options]
  * @param {string} [options.entryPoint] - Entry file (default: "src/index.ts")
@@ -70,13 +223,28 @@ export function htmlAssetsPlugin() {
 export async function buildMod(options = {}) {
     const esbuild = await import("esbuild");
     const isWatch = process.argv.includes("--watch");
+    const start = Date.now();
+
+    // Validate & auto-fix project structure
+    const fixes = validateProject();
+    for (const fix of fixes) {
+        if (fix.startsWith("WARNING")) logWarn(fix);
+        else logWarn(`Auto-fix: ${fix}`);
+    }
 
     prepareDist();
 
+    const assetCount = scanSourceAssets();
+    if (assetCount > 0) {
+        log(`Copied ${assetCount} asset(s)`);
+    }
+
+    const outfile = options.outfile || "dist/mod.js";
+
     const config = {
         entryPoints: [options.entryPoint || "src/index.ts"],
         bundle: true,
-        outfile: options.outfile || "dist/mod.js",
+        outfile,
         format: "cjs",
         platform: "neutral",
         target: "es2020",
@@ -86,11 +254,32 @@ export async function buildMod(options = {}) {
     };
 
     if (isWatch) {
-        const ctx = await esbuild.context(config);
+        const ctx = await esbuild.context({
+            ...config,
+            plugins: [
+                ...config.plugins,
+                {
+                    name: "rebuild-notify",
+                    setup(build) {
+                        let rebuildStart = Date.now();
+                        build.onStart(() => { rebuildStart = Date.now(); });
+                        build.onEnd((result) => {
+                            if (result.errors.length === 0) {
+                                prepareDist();
+                                scanSourceAssets();
+                                logSuccess(`Rebuilt in ${Date.now() - rebuildStart}ms → ${outfile}`);
+                            }
+                        });
+                    },
+                },
+            ],
+        });
         await ctx.watch();
-        console.log("Watching for changes...");
+        log("Watching for changes...");
     } else {
         await esbuild.build(config);
-        console.log("Build complete: " + config.outfile);
+        const elapsed = Date.now() - start;
+        const size = (fs.statSync(outfile).size / 1024).toFixed(1);
+        logSuccess(`Build complete in ${elapsed}ms → ${outfile} (${size} KB)`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotbunny/hackhub-content-sdk",
-    "version": "0.5.1",
+    "version": "0.6.0",
     "description": "Type definitions and build tools for HackHub mod development",
     "types": "index.d.ts",
     "exports": {