@vojtaholik/static-kit-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createStaticKitConfig, staticKitConfig } from "./vite-config.js";
+export { svgSpritePlugin, pagesPreviewPlugin, buildPlugins } from "./plugins/index.js";
+export { loadStaticKitConfig, normalizeBase, timeStamp } from "./utils/config.js";
+export { processHtmlImports } from "./utils/html-imports.js";
+export { scanDirectory, getInputEntries } from "./utils/file-scanner.js";
+export type { StaticKitConfig, StaticKitOptions, PagesPreviewOptions } from "./types.js";
+export type { SvgSpriteOptions, BuildPluginsOptions } from "./plugins/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAG1E,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,YAAY,EACb,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,SAAS,EACV,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// Main exports
+export { createStaticKitConfig, staticKitConfig } from "./vite-config.js";
+// Plugins
+export { svgSpritePlugin, pagesPreviewPlugin, buildPlugins } from "./plugins/index.js";
+// Utilities
+export { loadStaticKitConfig, normalizeBase, timeStamp } from "./utils/config.js";
+export { processHtmlImports } from "./utils/html-imports.js";
+export { scanDirectory, getInputEntries } from "./utils/file-scanner.js";

package/dist/plugins/build-plugins.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "vite";
+import type { StaticKitConfig } from "../types.js";
+export interface BuildPluginsOptions {
+    config: StaticKitConfig;
+    publicDir?: string;
+}
+export declare function buildPlugins(options: BuildPluginsOptions): Plugin[];
+//# sourceMappingURL=build-plugins.d.ts.map

package/dist/plugins/build-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-plugins.d.ts","sourceRoot":"","sources":["../../src/plugins/build-plugins.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAInC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AASD,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAoKnE"}

package/dist/plugins/build-plugins.js

@@ -0,0 +1,150 @@
+import fs from "fs/promises";
+import path from "path";
+import fg from "fast-glob";
+import { processHtmlImports } from "../utils/html-imports.js";
+import { normalizeBase, timeStamp } from "../utils/config.js";
+async function createHtaccessFile(distPath) {
+    await fs.writeFile(path.join(distPath, ".htaccess"), "DirectoryIndex index.html\nRewriteEngine On\nRewriteCond %{REQUEST_FILENAME} !-f\nRewriteCond %{REQUEST_FILENAME} !-d\nRewriteRule ^([^.]+)$ $1.html [L]");
+}
+export function buildPlugins(options) {
+    const { config, publicDir = "public" } = options;
+    const normalizedBase = normalizeBase(config.build?.base);
+    return [
+        // Create .htaccess file
+        {
+            name: "create-htaccess-file",
+            apply: "build",
+            writeBundle: async () => {
+                await createHtaccessFile("dist");
+            },
+        },
+        // Copy static assets
+        {
+            name: "copy-static-assets",
+            apply: "build",
+            writeBundle: async () => {
+                try {
+                    const srcPublicPath = path.resolve(publicDir);
+                    const destPublicPath = path.resolve(`dist/${normalizedBase}`);
+                    // Create dist/public directory
+                    await fs.mkdir(destPublicPath, { recursive: true });
+                    // Copy files from public/ to dist/public/ using fast-glob
+                    const allFiles = await fg("**/*", {
+                        cwd: srcPublicPath,
+                        onlyFiles: true,
+                        dot: true,
+                    });
+                    for (const file of allFiles) {
+                        const srcPath = path.join(srcPublicPath, file);
+                        const destPath = path.join(destPublicPath, file);
+                        // Ensure destination directory exists
+                        await fs.mkdir(path.dirname(destPath), { recursive: true });
+                        await fs.copyFile(srcPath, destPath);
+                    }
+                }
+                catch (error) {
+                    // Public directory doesn't exist or can't be copied
+                    console.warn("Could not copy public directory:", error);
+                }
+            },
+        },
+        // Process HTML files
+        {
+            name: "html-processor",
+            apply: "build",
+            writeBundle: async () => {
+                const distPath = path.resolve("dist");
+                // Find all HTML files in the dist directory using fast-glob
+                const findHtmlFiles = async (dir) => {
+                    try {
+                        return await fg("**/*.html", {
+                            cwd: dir,
+                            onlyFiles: true,
+                        });
+                    }
+                    catch (error) {
+                        return [];
+                    }
+                };
+                try {
+                    const htmlFiles = await findHtmlFiles(distPath);
+                    for (const htmlFile of htmlFiles) {
+                        const fullPath = path.join(distPath, htmlFile);
+                        // Check if this is a file that should be moved (in src/pages structure)
+                        if (htmlFile.startsWith("src/pages/")) {
+                            const cleanFileName = htmlFile.replace(/^src\/pages\//, "");
+                            const newPath = path.join(distPath, cleanFileName);
+                            // Read the file, process it, and write to new location
+                            const content = await fs.readFile(fullPath, "utf-8");
+                            const sourceDir = path.dirname(path.resolve("src/pages", cleanFileName));
+                            const processedContent = await processHtmlImports(content, sourceDir);
+                            // Remove any existing CSS and JS links that Vite injected
+                            const cleanedContent = processedContent
+                                .replace(/<link[^>]*rel=["']stylesheet["'][^>]*>/g, "")
+                                .replace(/<script[^>]*src=[^>]*><\/script>/g, "")
+                                .replace(/<use href=\"\/sprite.svg/g, () => {
+                                return `<use href=\"${normalizedBase}images/sprite.svg\?v=${timeStamp()}`;
+                            })
+                                // Normalize asset paths: Convert absolute paths to use configured base
+                                // Transform /public/images/... → public/images/... (based on normalizedBase)
+                                // Transform /images/... → public/images/... (shorthand syntax)
+                                // This ensures all asset references work with the custom build structure
+                                .replace(/src="\/public\//g, `src="${normalizedBase}`)
+                                .replace(/href="\/public\//g, `href="${normalizedBase}`)
+                                .replace(/src="\/images\//g, `src="${normalizedBase}images/`)
+                                .replace(/href="\/images\//g, `href="${normalizedBase}images/`)
+                                .trim();
+                            // Calculate asset paths based on page depth and base config
+                            const pathSegments = cleanFileName.split("/");
+                            const depth = pathSegments.length - 1;
+                            // For relative paths, go up directories then into configured base
+                            const relativePath = depth > 0 ? "../".repeat(depth) : "";
+                            const stylesPath = `${normalizedBase}css/styles.css?v=${timeStamp()}`;
+                            const jsPath = `${normalizedBase}js/index.js?v=${timeStamp()}`;
+                            // Create full HTML with correct paths
+                            const fullHtml = `<!DOCTYPE html>
+<html lang="${config.templates?.language || "en"}">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${cleanFileName.replace(".html", "")}</title>
+  <link rel="stylesheet" href="${stylesPath}">
+</head>
+<body>
+${cleanedContent}
+<script type="module" src="${jsPath}"></script>
+</body>
+</html>`;
+                            // Create directory if needed
+                            await fs.mkdir(path.dirname(newPath), { recursive: true });
+                            // Write to new location
+                            await fs.writeFile(newPath, fullHtml);
+                            // Remove old file
+                            await fs.unlink(fullPath);
+                            // Remove empty directories
+                            let dirToCheck = path.dirname(fullPath);
+                            while (dirToCheck !== distPath) {
+                                try {
+                                    const items = await fs.readdir(dirToCheck);
+                                    if (items.length === 0) {
+                                        await fs.rmdir(dirToCheck);
+                                        dirToCheck = path.dirname(dirToCheck);
+                                    }
+                                    else {
+                                        break;
+                                    }
+                                }
+                                catch {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Error processing HTML files:", error);
+                }
+            },
+        },
+    ];
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { svgSpritePlugin } from "./svg-sprite.js";
+export { pagesPreviewPlugin } from "./pages-preview.js";
+export { buildPlugins } from "./build-plugins.js";
+export type { SvgSpriteOptions } from "./svg-sprite.js";
+export type { PagesPreviewOptions } from "../types.js";
+export type { BuildPluginsOptions } from "./build-plugins.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/plugins/index.js

@@ -0,0 +1,3 @@
+export { svgSpritePlugin } from "./svg-sprite.js";
+export { pagesPreviewPlugin } from "./pages-preview.js";
+export { buildPlugins } from "./build-plugins.js";

package/dist/plugins/pages-preview.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+import type { PagesPreviewOptions } from "../types.js";
+export declare function pagesPreviewPlugin(options?: PagesPreviewOptions): Plugin;
+//# sourceMappingURL=pages-preview.d.ts.map

package/dist/plugins/pages-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages-preview.d.ts","sourceRoot":"","sources":["../../src/plugins/pages-preview.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAwMvD,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAuJ5E"}

package/dist/plugins/pages-preview.js

@@ -0,0 +1,292 @@
+import fs from "fs/promises";
+import path from "path";
+import fg from "fast-glob";
+import { processHtmlImports } from "../utils/html-imports.js";
+async function scanPagesDirectory(pagesDir) {
+    try {
+        const htmlFiles = await fg("**/*.html", {
+            cwd: pagesDir,
+            onlyFiles: true,
+            ignore: ["node_modules/**"],
+        });
+        const pages = htmlFiles.map((file) => file.replace(".html", ""));
+        return pages.sort();
+    }
+    catch (error) {
+        // Directory doesn't exist or can't be read
+        return [];
+    }
+}
+function generatePagesIndex(pages, components, routePrefix, componentsRoutePrefix) {
+    // Group pages by directory
+    const pagesByDir = {};
+    const componentsByDir = {};
+    for (const page of pages) {
+        const parts = page.split(path.sep);
+        if (parts.length === 1) {
+            // Root level page
+            if (!pagesByDir[""])
+                pagesByDir[""] = [];
+            pagesByDir[""].push(page);
+        }
+        else {
+            // Nested page
+            const dir = parts.slice(0, -1).join("/");
+            if (!pagesByDir[dir])
+                pagesByDir[dir] = [];
+            pagesByDir[dir].push(page);
+        }
+    }
+    for (const component of components) {
+        const parts = component.split(path.sep);
+        if (parts.length === 1) {
+            // Root level component
+            if (!componentsByDir[""])
+                componentsByDir[""] = [];
+            componentsByDir[""].push(component);
+        }
+        else {
+            // Nested component
+            const dir = parts.slice(0, -1).join("/");
+            if (!componentsByDir[dir])
+                componentsByDir[dir] = [];
+            componentsByDir[dir].push(component);
+        }
+    }
+    // Generate HTML sections
+    let sectionsHtml = "";
+    // Root pages first
+    if (pagesByDir[""]) {
+        sectionsHtml += `
+  <section>
+    <h2>📄 Pages</h2>
+    <ul>
+      ${pagesByDir[""]
+            .map((page) => `<li><a href="${routePrefix}/${page}">${page}</a></li>`)
+            .join("\n      ")}
+    </ul>
+  </section>`;
+    }
+    // Then subdirectory pages
+    const sortedPageDirs = Object.keys(pagesByDir)
+        .filter((dir) => dir !== "")
+        .sort();
+    for (const dir of sortedPageDirs) {
+        sectionsHtml += `
+  <section>
+    <h2>📁 pages/${dir}/</h2>
+    <ul>
+      ${pagesByDir[dir]
+            .map((page) => {
+            const fileName = page.split("/").pop();
+            return `<li><a href="${routePrefix}/${page}">${fileName}</a></li>`;
+        })
+            .join("\n      ")}
+    </ul>
+  </section>`;
+    }
+    // Root components
+    if (componentsByDir[""]) {
+        sectionsHtml += `
+  <section>
+    <h2>🧩 Components</h2>
+    <ul>
+      ${componentsByDir[""]
+            .map((component) => `<li><a href="${componentsRoutePrefix}/${component}">${component}</a></li>`)
+            .join("\n      ")}
+    </ul>
+  </section>`;
+    }
+    // Then subdirectory components
+    const sortedComponentDirs = Object.keys(componentsByDir)
+        .filter((dir) => dir !== "")
+        .sort();
+    for (const dir of sortedComponentDirs) {
+        sectionsHtml += `
+  <section>
+    <h2>📁 components/${dir}/</h2>
+    <ul>
+      ${componentsByDir[dir]
+            .map((component) => {
+            const fileName = component.split("/").pop();
+            return `<li><a href="${componentsRoutePrefix}/${component}">${fileName}</a></li>`;
+        })
+            .join("\n      ")}
+    </ul>
+  </section>`;
+    }
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Pages & Components Preview</title>
+  <script type="module" src="/@vite/client"></script>
+  <link rel="stylesheet" href="/style.css">
+  <style>
+    body {
+      font-family: system-ui, sans-serif;
+      max-width: 800px;
+      margin: 2rem auto;
+      padding: 0 1rem;
+      line-height: 1.6;
+    }
+    h1 {
+      color: #333;
+      border-bottom: 2px solid #eee;
+      padding-bottom: 0.5rem;
+    }
+    ul {
+      list-style: none;
+      padding: 0;
+    }
+    li {
+      margin: 0.5rem 0;
+    }
+    a {
+      display: block;
+      padding: 0.75rem 1rem;
+      text-decoration: none;
+      color: #0066cc;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      transition: all 0.2s;
+    }
+    a:hover {
+      background: #f5f5f5;
+      border-color: #0066cc;
+    }
+  </style>
+</head>
+<body>
+  <h1>📄 Pages & Components Preview</h1>
+  <p>Available pages and components in your file system:</p>
+  ${sectionsHtml}
+</body>
+</html>`;
+}
+function generateFullPage(pageName, pageContent) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${pageName}</title>
+  <script type="module" src="/@vite/client"></script>
+  <link rel="icon" href="/favicon.ico">
+  <link rel="stylesheet" href="/src/styles/main.scss">
+  <script type="module" src="/src/js/index.ts"></script>
+  <script type="module" src="/svg-sprite-hmr.ts"></script>
+
+</head>
+<body>
+ 
+    ${pageContent}
+ 
+  <!-- <a href="/" class="back-link">← Back to all pages</a> -->
+</body>
+</html>`;
+}
+export function pagesPreviewPlugin(options = {}) {
+    const { pagesDir = "src/pages", componentsDir = "src/components", routePrefix = "/pages", componentsRoutePrefix = "/components", } = options;
+    return {
+        name: "vite-pages-preview",
+        apply: "serve",
+        configureServer(server) {
+            // Watch the pages and components directories for changes and force browser reload
+            const pagesPath = path.resolve(pagesDir);
+            const componentsPath = path.resolve(componentsDir);
+            server.watcher.add(pagesPath);
+            server.watcher.add(componentsPath);
+            const reloadBrowser = () => {
+                // Force a hard refresh of the browser
+                server.ws.send({
+                    type: "full-reload",
+                });
+                // Also send update message for good measure
+                server.ws.send({
+                    type: "update",
+                    updates: [],
+                });
+            };
+            server.watcher.on("change", (filePath) => {
+                const resolvedPath = path.resolve(filePath);
+                if (resolvedPath.startsWith(pagesPath) ||
+                    resolvedPath.startsWith(componentsPath)) {
+                    console.log(`[pages-preview] File changed: ${filePath}`);
+                    reloadBrowser();
+                }
+            });
+            server.watcher.on("add", (filePath) => {
+                const resolvedPath = path.resolve(filePath);
+                if ((resolvedPath.startsWith(pagesPath) ||
+                    resolvedPath.startsWith(componentsPath)) &&
+                    filePath.endsWith(".html")) {
+                    console.log(`[pages-preview] File added: ${filePath}`);
+                    reloadBrowser();
+                }
+            });
+            server.watcher.on("unlink", (filePath) => {
+                const resolvedPath = path.resolve(filePath);
+                if ((resolvedPath.startsWith(pagesPath) ||
+                    resolvedPath.startsWith(componentsPath)) &&
+                    filePath.endsWith(".html")) {
+                    console.log(`[pages-preview] File deleted: ${filePath}`);
+                    reloadBrowser();
+                }
+            });
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url;
+                // Handle preview index route
+                if (url === `/`) {
+                    const pages = await scanPagesDirectory(pagesDir);
+                    const components = await scanPagesDirectory(componentsDir);
+                    const indexHtml = generatePagesIndex(pages, components, routePrefix, componentsRoutePrefix);
+                    res.setHeader("Content-Type", "text/html");
+                    res.end(indexHtml);
+                    return;
+                }
+                // Handle individual page routes
+                if (url?.startsWith(`${routePrefix}/`) && url !== `${routePrefix}/`) {
+                    const pageName = url
+                        .replace(`${routePrefix}/`, "")
+                        .replace(/\/$/, "");
+                    const pageFile = path.join(pagesDir, `${pageName}.html`);
+                    try {
+                        const rawPageContent = await fs.readFile(pageFile, "utf-8");
+                        // Process HTML imports before generating full page
+                        const processedPageContent = await processHtmlImports(rawPageContent, path.dirname(pageFile));
+                        const fullPageHtml = generateFullPage(pageName, processedPageContent);
+                        res.setHeader("Content-Type", "text/html");
+                        res.end(fullPageHtml);
+                        return;
+                    }
+                    catch (error) {
+                        // Page not found, continue to next middleware
+                    }
+                }
+                // Handle individual component routes
+                if (url?.startsWith(`${componentsRoutePrefix}/`) &&
+                    url !== `${componentsRoutePrefix}/`) {
+                    const componentName = url
+                        .replace(`${componentsRoutePrefix}/`, "")
+                        .replace(/\/$/, "");
+                    const componentFile = path.join(componentsDir, `${componentName}.html`);
+                    try {
+                        const rawComponentContent = await fs.readFile(componentFile, "utf-8");
+                        // Process HTML imports before generating full page
+                        const processedComponentContent = await processHtmlImports(rawComponentContent, path.dirname(componentFile));
+                        const fullPageHtml = generateFullPage(`component: ${componentName}`, processedComponentContent);
+                        res.setHeader("Content-Type", "text/html");
+                        res.end(fullPageHtml);
+                        return;
+                    }
+                    catch (error) {
+                        // Component not found, continue to next middleware
+                    }
+                }
+                next();
+            });
+        },
+    };
+}

package/dist/plugins/svg-sprite.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "vite";
+export interface SvgSpriteOptions {
+    iconsDir?: string;
+    outputPath?: string;
+    publicPath?: string;
+}
+export declare function svgSpritePlugin(options?: SvgSpriteOptions): Plugin[];
+//# sourceMappingURL=svg-sprite.d.ts.map

package/dist/plugins/svg-sprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg-sprite.d.ts","sourceRoot":"","sources":["../../src/plugins/svg-sprite.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAInC,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4DD,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,EAAE,CA0DxE"}

package/dist/plugins/svg-sprite.js

@@ -0,0 +1,98 @@
+import fs from "fs/promises";
+import path from "path";
+import { optimize } from "svgo";
+import { scanDirectory } from "../utils/file-scanner.js";
+async function generateSvgSprite(iconsDir, outputPath) {
+    const svgFiles = await scanDirectory(iconsDir, [".svg"]);
+    if (svgFiles.length === 0) {
+        return;
+    }
+    const symbols = [];
+    for (const file of svgFiles) {
+        try {
+            const filePath = path.join(iconsDir, file);
+            const svgContent = await fs.readFile(filePath, "utf-8");
+            // Optimize with SVGO
+            const result = optimize(svgContent, {
+                plugins: [
+                    {
+                        name: "removeAttrs",
+                        params: { attrs: "data-name" },
+                    },
+                ],
+            });
+            // Extract the inner content of the SVG and create a symbol
+            const optimizedSvg = result.data;
+            const svgMatch = optimizedSvg.match(/<svg[^>]*>([\s\S]*?)<\/svg>/);
+            if (svgMatch) {
+                const iconName = path.basename(file, ".svg");
+                const innerContent = svgMatch[1];
+                // Extract viewBox from the original SVG
+                const viewBoxMatch = optimizedSvg.match(/viewBox="([^"]*)"/);
+                const viewBox = viewBoxMatch ? ` viewBox="${viewBoxMatch[1]}"` : "";
+                const symbol = `<symbol id="${iconName}"${viewBox}>${innerContent}</symbol>`;
+                symbols.push(symbol);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to process ${file}:`, error);
+        }
+    }
+    if (symbols.length > 0) {
+        const sprite = `<svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
+${symbols.join("\n")}
+</svg>`;
+        // Ensure the output directory exists
+        await fs.mkdir(path.dirname(outputPath), { recursive: true });
+        await fs.writeFile(outputPath, sprite);
+        console.log(`📦 Generated sprite with ${symbols.length} icons at ${outputPath}`);
+    }
+}
+export function svgSpritePlugin(options = {}) {
+    const { iconsDir = "src/icons", outputPath = "public/images/sprite.svg", publicPath = "public/" } = options;
+    return [
+        // Development plugin
+        {
+            name: "svg-sprite-dev",
+            apply: "serve",
+            configureServer(server) {
+                // Generate sprite on server start
+                generateSvgSprite(iconsDir, outputPath);
+                // Watch for changes in icons directory
+                server.watcher.add(`${iconsDir}/**/*.svg`);
+                const handleSpriteChange = async (file) => {
+                    console.log("📁 File change detected:", file);
+                    if (file.includes(iconsDir) && file.endsWith(".svg")) {
+                        console.log("🎨 SVG file changed, regenerating sprite...");
+                        await generateSvgSprite(iconsDir, outputPath);
+                        const timestamp = Date.now();
+                        console.log("📡 Sending HMR event with timestamp:", timestamp);
+                        // Send a custom HMR update to invalidate SVG references
+                        server.ws.send({
+                            type: "custom",
+                            event: "svg-sprite-updated",
+                            data: { timestamp },
+                        });
+                        console.log("✅ SVG sprite updated and HMR event sent");
+                    }
+                    else {
+                        console.log("⏭️  Not an SVG file, skipping");
+                    }
+                };
+                server.watcher.on("change", handleSpriteChange);
+                server.watcher.on("add", handleSpriteChange);
+                server.watcher.on("unlink", handleSpriteChange);
+            },
+        },
+        // Build plugin
+        {
+            name: "svg-sprite-build",
+            apply: "build",
+            buildStart() {
+                // Generate sprite at build start
+                const buildOutputPath = outputPath.replace("public/", `dist/${publicPath}`);
+                return generateSvgSprite(iconsDir, buildOutputPath);
+            },
+        },
+    ];
+}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export interface StaticKitConfig {
+    build?: {
+        base?: string;
+        output?: string;
+    };
+    templates?: {
+        language?: string;
+    };
+}
+export interface StaticKitOptions {
+    config?: StaticKitConfig;
+    pagesDir?: string;
+    componentsDir?: string;
+    iconsDir?: string;
+    stylesEntry?: string;
+    jsEntry?: string;
+    publicDir?: string;
+}
+export interface PagesPreviewOptions {
+    pagesDir?: string;
+    componentsDir?: string;
+    routePrefix?: string;
+    componentsRoutePrefix?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,CAAC,EAAE;QACV,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/config.d.ts

@@ -0,0 +1,5 @@
+import type { StaticKitConfig } from "../types.js";
+export declare function loadStaticKitConfig(root?: string): Promise<StaticKitConfig>;
+export declare function normalizeBase(input?: string): string;
+export declare function timeStamp(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAsB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAqBjF;AAED,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAKpD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC"}

package/dist/utils/config.js

@@ -0,0 +1,34 @@
+import fs from "fs/promises";
+import path from "path";
+export async function loadStaticKitConfig(root) {
+    const projectRoot = root || process.cwd();
+    const baseConfigPath = path.join(projectRoot, "static-kit.config.json");
+    const localConfigPath = path.join(projectRoot, "static-kit.local.json");
+    const result = {};
+    try {
+        const raw = await fs.readFile(baseConfigPath, "utf8");
+        Object.assign(result, JSON.parse(raw));
+    }
+    catch {
+        // Config file doesn't exist or can't be read
+    }
+    try {
+        const rawLocal = await fs.readFile(localConfigPath, "utf8");
+        Object.assign(result, JSON.parse(rawLocal));
+    }
+    catch {
+        // Local config file doesn't exist or can't be read
+    }
+    return result;
+}
+export function normalizeBase(input) {
+    if (!input)
+        return "public/";
+    let base = input.trim();
+    if (!base.endsWith("/"))
+        base = base + "/";
+    return base;
+}
+export function timeStamp() {
+    return Date.now().toString().slice(0, 10);
+}

package/dist/utils/file-scanner.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Scan directory for files with specified extensions using fast-glob
+ */
+export declare function scanDirectory(dir: string, extensions: string[]): Promise<string[]>;
+/**
+ * Get input entries for Vite build
+ */
+export declare function getInputEntries(pagesDir?: string, jsDir?: string, stylesEntry?: string): Promise<Record<string, string>>;
+//# sourceMappingURL=file-scanner.d.ts.map

package/dist/utils/file-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-scanner.d.ts","sourceRoot":"","sources":["../../src/utils/file-scanner.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,MAAM,EAAE,CAAC,CAanB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,QAAQ,GAAE,MAAoB,EAC9B,KAAK,GAAE,MAAiB,EACxB,WAAW,GAAE,MAA+B,mCAsB7C"}

package/dist/utils/file-scanner.js

@@ -0,0 +1,40 @@
+import fg from "fast-glob";
+/**
+ * Scan directory for files with specified extensions using fast-glob
+ */
+export async function scanDirectory(dir, extensions) {
+    try {
+        const patterns = extensions.map((ext) => `**/*${ext}`);
+        const files = await fg(patterns, {
+            cwd: dir,
+            onlyFiles: true,
+            ignore: ["node_modules/**"],
+        });
+        return files;
+    }
+    catch (error) {
+        // Directory doesn't exist or can't be read
+        return [];
+    }
+}
+/**
+ * Get input entries for Vite build
+ */
+export async function getInputEntries(pagesDir = "src/pages", jsDir = "src/js", stylesEntry = "src/styles/main.scss") {
+    const entries = {};
+    // Always include main SCSS
+    entries.main = stylesEntry;
+    // Dynamically scan for JS/TS files (including nested)
+    const jsFiles = await scanDirectory(jsDir, [".ts", ".js"]);
+    for (const file of jsFiles) {
+        const name = file.replace(/\.(ts|js)$/, "");
+        entries[`js/${name}`] = `${jsDir}/${file}`;
+    }
+    // Dynamically scan for HTML pages (including nested)
+    const pageFiles = await scanDirectory(pagesDir, [".html"]);
+    for (const file of pageFiles) {
+        const name = file.replace(".html", "");
+        entries[name] = `${pagesDir}/${file}`;
+    }
+    return entries;
+}

package/dist/utils/html-imports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Process HTML imports in the given HTML string
+ * Supports both relative paths and @components/ prefix
+ */
+export declare function processHtmlImports(html: string, dir: string): Promise<string>;
+//# sourceMappingURL=html-imports.d.ts.map

package/dist/utils/html-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-imports.d.ts","sourceRoot":"","sources":["../../src/utils/html-imports.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,CAoEjB"}

package/dist/utils/html-imports.js

@@ -0,0 +1,69 @@
+import fs from "fs/promises";
+import path from "path";
+/**
+ * Process HTML imports in the given HTML string
+ * Supports both relative paths and @components/ prefix
+ */
+export async function processHtmlImports(html, dir) {
+    const importRegex = /<!--\s*@import:\s*([\w./@-]+)\s*-->/g;
+    // Collect all matches first to avoid issues with changing string length
+    const matches = Array.from(html.matchAll(importRegex));
+    // Process matches in reverse order to maintain correct indices
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const match = matches[i];
+        let importPath = match[1];
+        // Handle @components/ prefix for cleaner component imports
+        if (importPath.startsWith("@components/")) {
+            // Find the project root (go up from current dir until we find src/)
+            let currentDir = dir;
+            while (!currentDir.endsWith("src") &&
+                currentDir !== path.dirname(currentDir)) {
+                currentDir = path.dirname(currentDir);
+            }
+            if (currentDir.endsWith("src") || currentDir.includes("src")) {
+                const srcDir = currentDir.endsWith("src")
+                    ? currentDir
+                    : path.join(currentDir, "src");
+                importPath = importPath.replace("@components/", "components/");
+                const filePath = path.resolve(srcDir, importPath);
+                try {
+                    const fileContent = await fs.readFile(filePath, "utf8");
+                    html =
+                        html.slice(0, match.index) +
+                            fileContent +
+                            html.slice(match.index + match[0].length);
+                    continue;
+                }
+                catch (error) {
+                    const errorMessage = `<!-- Import Error: Could not find component "${match[1]}" 
+                 Looked for: ${filePath}
+                 Check the path and make sure the file exists -->`;
+                    html =
+                        html.slice(0, match.index) +
+                            errorMessage +
+                            html.slice(match.index + match[0].length);
+                    continue;
+                }
+            }
+        }
+        // Standard relative path resolution
+        const filePath = path.resolve(dir, importPath);
+        try {
+            const fileContent = await fs.readFile(filePath, "utf8");
+            html =
+                html.slice(0, match.index) +
+                    fileContent +
+                    html.slice(match.index + match[0].length);
+        }
+        catch (error) {
+            const errorMessage = `<!-- Import Error: Could not find file "${match[1]}" 
+             Looked for: ${filePath}
+             Check the path and make sure the file exists -->`;
+            html =
+                html.slice(0, match.index) +
+                    errorMessage +
+                    html.slice(match.index + match[0].length);
+        }
+    }
+    return html;
+}

package/dist/vite-config.d.ts

@@ -0,0 +1,5 @@
+import type { UserConfigFnPromise } from "vite";
+import type { StaticKitOptions } from "./types.js";
+export declare function createStaticKitConfig(options?: StaticKitOptions): Promise<UserConfigFnPromise>;
+export declare function staticKitConfig(options?: StaticKitOptions): Promise<UserConfigFnPromise>;
+//# sourceMappingURL=vite-config.d.ts.map

package/dist/vite-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-config.d.ts","sourceRoot":"","sources":["../src/vite-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAI5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,wBAAsB,qBAAqB,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8ExG;AAGD,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,gCAE7D"}

package/dist/vite-config.js

@@ -0,0 +1,75 @@
+import { defineConfig } from "vite";
+import { loadStaticKitConfig, normalizeBase } from "./utils/config.js";
+import { getInputEntries } from "./utils/file-scanner.js";
+import { svgSpritePlugin, pagesPreviewPlugin, buildPlugins } from "./plugins/index.js";
+export async function createStaticKitConfig(options = {}) {
+    const { config: userProvidedConfig, pagesDir = "src/pages", componentsDir = "src/components", iconsDir = "src/icons", stylesEntry = "src/styles/main.scss", jsEntry = "src/js", publicDir = "public" } = options;
+    // Load config from file system if not provided
+    const config = userProvidedConfig || await loadStaticKitConfig();
+    const normalizedBase = normalizeBase(config.build?.base);
+    return defineConfig(async ({ command }) => {
+        if (command === "serve") {
+            return {
+                plugins: [
+                    pagesPreviewPlugin({
+                        pagesDir,
+                        componentsDir,
+                    }),
+                    ...svgSpritePlugin({
+                        iconsDir,
+                        outputPath: `${publicDir}/images/sprite.svg`,
+                        publicPath: normalizedBase
+                    }),
+                ],
+                publicDir, // Static assets during dev
+            };
+        }
+        // Build configuration with dynamic inputs
+        const inputEntries = await getInputEntries(pagesDir, jsEntry, stylesEntry);
+        console.log("📦 Building with entries:", Object.keys(inputEntries));
+        return {
+            build: {
+                outDir: config.build?.output || "dist",
+                emptyOutDir: true,
+                cssCodeSplit: false, // Single CSS file
+                rollupOptions: {
+                    input: inputEntries,
+                    output: {
+                        entryFileNames: (chunkInfo) => {
+                            if (chunkInfo.name?.startsWith("js/")) {
+                                return `${normalizedBase}[name].js`;
+                            }
+                            return `${normalizedBase}[name].js`;
+                        },
+                        assetFileNames: (assetInfo) => {
+                            if (assetInfo.name?.endsWith(".css")) {
+                                return `${normalizedBase}css/styles.css`;
+                            }
+                            if (assetInfo.name === "sprite.svg") {
+                                // Ensure sprite lands under public if emitted by Rollup
+                                return `${normalizedBase}images/sprite.svg`;
+                            }
+                            return `${normalizedBase}assets/[name]-[hash][extname]`;
+                        },
+                    },
+                },
+            },
+            publicDir: "", // Disable default public dir copying
+            plugins: [
+                ...svgSpritePlugin({
+                    iconsDir,
+                    outputPath: `dist/${normalizedBase}images/sprite.svg`,
+                    publicPath: normalizedBase
+                }),
+                ...buildPlugins({
+                    config,
+                    publicDir
+                }),
+            ],
+        };
+    });
+}
+// Convenience function that matches the current API
+export function staticKitConfig(options = {}) {
+    return createStaticKitConfig(options);
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@vojtaholik/static-kit-core",
+  "version": "1.0.0",
+  "description": "Core library for Static Kit - simple static site framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite-config.d.ts",
+      "import": "./dist/vite-config.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/plugins/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "templates/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "vite": "^7.0.0"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "svgo": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1",
+    "typescript": "~5.9.2",
+    "vite": "^7.1.1"
+  },
+  "keywords": [
+    "static-site",
+    "vite",
+    "html",
+    "scss",
+    "typescript",
+    "components"
+  ],
+  "author": "Vojta Holik <vojta@hey.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vojtaholik/static-kit.git",
+    "directory": "packages/static-kit-core"
+  },
+  "homepage": "https://github.com/vojtaholik/static-kit#readme",
+  "bugs": {
+    "url": "https://github.com/vojtaholik/static-kit/issues"
+  }
+}