svelteesp32 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,235 +1,30 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateExtensionGroup = exports.shouldUseGzip = exports.formatSizePrecise = exports.formatSize = exports.formatDryRunRoutes = exports.formatCompressionLog = exports.formatAnalyzeTable = exports.createSourceEntry = exports.calculateCompressionRatio = void 0;
+exports.updateExtensionGroup = exports.shouldUseGzip = exports.formatSizePrecise = exports.formatSize = exports.formatDryRunRoutes = exports.formatCompressionLog = exports.formatChangeSummary = exports.formatAnalyzeTable = exports.createSourceEntry = exports.calculateCompressionRatio = void 0;
 exports.main = main;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const node_zlib_1 = require("node:zlib");
-const mime_types_1 = require("mime-types");
 const commandLine_1 = require("./commandLine");
-const consoleColor_1 = require("./consoleColor");
-const cppCode_1 = require("./cppCode");
-const errorMessages_1 = require("./errorMessages");
-const file_1 = require("./file");
-const GZIP_MIN_SIZE = 1024;
-const GZIP_MIN_REDUCTION_RATIO = 0.85;
-const shouldUseGzip = (originalSize, compressedSize) => originalSize > GZIP_MIN_SIZE && compressedSize < originalSize * GZIP_MIN_REDUCTION_RATIO;
-exports.shouldUseGzip = shouldUseGzip;
-const calculateCompressionRatio = (originalSize, compressedSize) => Math.round((compressedSize / originalSize) * 100);
-exports.calculateCompressionRatio = calculateCompressionRatio;
-const formatCompressionLog = (filename, padding, originalSize, compressedSize, useGzip) => {
-    const ratio = calculateCompressionRatio(originalSize, compressedSize);
-    const sizeInfo = `(${originalSize} -> ${compressedSize} = ${ratio}%)`;
-    if (useGzip)
-        return (0, consoleColor_1.greenLog)(` [${filename}] ${padding} ✓ gzip used ${sizeInfo}`);
-    const tooSmall = originalSize <= GZIP_MIN_SIZE ? '(too small) ' : '';
-    return (0, consoleColor_1.yellowLog)(` [${filename}] ${padding} x gzip unused ${tooSmall}${sizeInfo}`);
-};
-exports.formatCompressionLog = formatCompressionLog;
-const formatSize = (bytes) => {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    return `${Math.round(bytes / 1024)}kB`;
-};
-exports.formatSize = formatSize;
-const formatSizePrecise = (bytes) => {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    return `${(bytes / 1024).toFixed(1)}kB`;
-};
-exports.formatSizePrecise = formatSizePrecise;
-const createSourceEntry = (filename, dataname, content, contentGzip, mimeType, sha256, isGzip) => ({
-    filename,
-    dataname,
-    datanameUpperCase: dataname.toUpperCase(),
-    content,
-    contentGzip: isGzip ? contentGzip : content,
-    isGzip,
-    mime: mimeType,
-    sha256
-});
-exports.createSourceEntry = createSourceEntry;
-const updateExtensionGroup = (filesByExtension, extension) => {
-    const group = filesByExtension.find((fe) => fe.extension === extension);
-    if (group)
-        group.count += 1;
-    else
-        filesByExtension.push({ extension, count: 1 });
-};
-exports.updateExtensionGroup = updateExtensionGroup;
-const sizeCellFor = (s) => {
-    const orig = formatSize(s.content.length);
-    if (s.isGzip)
-        return `${orig} → ${formatSize(s.contentGzip.length)}`;
-    return orig;
-};
-const formatDryRunRoutes = (sources, engine, basePath, spa) => {
-    if (sources.length === 0)
-        return '  (no files)';
-    const defaultSource = sources.find((s) => s.filename === 'index.html' || s.filename === 'index.htm');
-    const rows = [];
-    if (defaultSource)
-        rows.push({
-            url: basePath || '/',
-            mime: defaultSource.mime,
-            sizeCell: sizeCellFor(defaultSource),
-            tag: '[default]'
-        });
-    for (const source of sources)
-        rows.push({
-            url: `${basePath}/${source.filename}`,
-            mime: source.mime,
-            sizeCell: sizeCellFor(source),
-            tag: source.isGzip ? '' : '[no gzip]'
-        });
-    if (spa && defaultSource) {
-        const spaUrl = engine === 'psychic' && basePath ? `${basePath}/*` : '(SPA catch-all)';
-        rows.push({ url: spaUrl, mime: defaultSource.mime, sizeCell: '', tag: '[SPA catch-all → index.html]' });
-    }
-    const urlWidth = Math.max(...rows.map((r) => r.url.length));
-    const mimeWidth = Math.max(...rows.map((r) => r.mime.length));
-    const sizeWidth = Math.max(...rows.map((r) => r.sizeCell.length));
-    return rows
-        .map((r) => {
-        const tagPart = r.tag ? `  ${r.tag}` : '';
-        return `  GET ${r.url.padEnd(urlWidth)}  ${r.mime.padEnd(mimeWidth)}  ${r.sizeCell.padEnd(sizeWidth)}${tagPart}`.trimEnd();
-    })
-        .join('\n');
-};
-exports.formatDryRunRoutes = formatDryRunRoutes;
-const formatAnalyzeTable = (sources, summary, maxSize, maxGzipSize) => {
-    const rows = sources.map((s) => ({
-        file: s.filename,
-        orig: formatSizePrecise(s.content.length),
-        gzip: formatSizePrecise(s.isGzip ? s.contentGzip.length : s.content.length),
-        tag: s.isGzip ? '' : '[no gzip]'
-    }));
-    const fileWidth = Math.max(4, ...rows.map((r) => r.file.length), 'Total'.length);
-    const origWidth = Math.max(8, ...rows.map((r) => r.orig.length), formatSizePrecise(summary.size).length);
-    const gzipWidth = Math.max(8, ...rows.map((r) => r.gzip.length), formatSizePrecise(summary.gzipsize).length);
-    const separator = `${'─'.repeat(fileWidth)}  ${'─'.repeat(origWidth)}  ${'─'.repeat(gzipWidth)}`;
-    const header = `${'File'.padEnd(fileWidth)}  ${'Original'.padEnd(origWidth)}  ${'Gzip'.padEnd(gzipWidth)}`;
-    const dataRows = rows.map((r) => {
-        const tagPart = r.tag ? `  ${r.tag}` : '';
-        return `${r.file.padEnd(fileWidth)}  ${r.orig.padEnd(origWidth)}  ${r.gzip.padEnd(gzipWidth)}${tagPart}`.trimEnd();
-    });
-    const totalOrig = formatSizePrecise(summary.size);
-    const totalGzip = formatSizePrecise(summary.gzipsize);
-    const totalRow = `${'Total'.padEnd(fileWidth)}  ${totalOrig.padEnd(origWidth)}  ${totalGzip.padEnd(gzipWidth)}`;
-    const lines = [header, separator, ...dataRows, separator, totalRow];
-    if (maxSize !== undefined) {
-        const pass = summary.size <= maxSize;
-        const budgetRow = `${'Budget (maxsize)'.padEnd(fileWidth)}  ${formatSizePrecise(maxSize).padEnd(origWidth)}  ${'-'.padEnd(gzipWidth)}  ${pass ? '✓ PASS' : '✗ FAIL'}`;
-        lines.push(budgetRow);
-    }
-    if (maxGzipSize !== undefined) {
-        const pass = summary.gzipsize <= maxGzipSize;
-        const budgetRow = `${'Budget (maxgzipsize)'.padEnd(fileWidth)}  ${'-'.padEnd(origWidth)}  ${formatSizePrecise(maxGzipSize).padEnd(gzipWidth)}  ${pass ? '✓ PASS' : '✗ FAIL'}`;
-        lines.push(budgetRow);
-    }
-    return lines.join('\n');
-};
-exports.formatAnalyzeTable = formatAnalyzeTable;
+const pipeline_1 = require("./pipeline");
 function main() {
-    const summary = {
-        filecount: 0,
-        size: 0,
-        gzipsize: 0
-    };
-    const sources = [];
-    const filesByExtension = [];
-    console.log('Collecting source files');
-    const files = (0, file_1.getFiles)();
-    if (files.size === 0) {
-        console.error(`Directory ${commandLine_1.cmdLine.sourcepath} is empty`);
+    try {
+        (0, pipeline_1.runPipeline)(commandLine_1.cmdLine);
+    }
+    catch (error) {
+        if (!(error instanceof pipeline_1.OverBudgetError)) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message)
+                console.error(message);
+        }
         process.exit(1);
     }
-    if (commandLine_1.cmdLine.spa && ![...files.keys()].some((f) => f === 'index.html' || f === 'index.htm'))
-        console.warn((0, consoleColor_1.yellowLog)('[SvelteESP32] Warning: --spa is set but no index.html/index.htm found; catch-all will not be generated.'));
-    console.log();
-    console.log('Translation to header file');
-    const longestFilename = [...files.keys()].reduce((p, c) => Math.max(c.length, p), 0);
-    for (const [originalFilename, fileData] of files) {
-        const { content, hash: sha256 } = fileData;
-        const rawMime = (0, mime_types_1.lookup)(originalFilename);
-        if (!rawMime)
-            console.log((0, consoleColor_1.yellowLog)(` [${originalFilename}] unknown MIME type for extension '${node_path_1.default.extname(originalFilename)}', using text/plain`));
-        const mimeType = rawMime || 'text/plain';
-        summary.filecount++;
-        const filename = originalFilename.replace(/\\/g, '/');
-        let dataname = filename.replace(/\W/g, '_');
-        if (/^\d/.test(dataname))
-            dataname = '_' + dataname;
-        let extension = node_path_1.default.extname(filename).toUpperCase();
-        if (extension.startsWith('.'))
-            extension = extension.slice(1);
-        updateExtensionGroup(filesByExtension, extension);
-        summary.size += content.length;
-        const zipContent = (0, node_zlib_1.gzipSync)(content, { level: 9 });
-        const useGzip = shouldUseGzip(content.length, zipContent.length);
-        summary.gzipsize += useGzip ? zipContent.length : content.length;
-        sources.push(createSourceEntry(filename, dataname, content, zipContent, mimeType, sha256, useGzip));
-        const padding = ' '.repeat(longestFilename - originalFilename.length);
-        console.log(formatCompressionLog(originalFilename, padding, content.length, zipContent.length, useGzip));
-    }
-    console.log('');
-    filesByExtension.sort((left, right) => left.extension.localeCompare(right.extension));
-    if (commandLine_1.cmdLine.analyze) {
-        console.log(formatAnalyzeTable(sources, summary, commandLine_1.cmdLine.maxSize, commandLine_1.cmdLine.maxGzipSize));
-        const overBudget = (commandLine_1.cmdLine.maxSize !== undefined && summary.size > commandLine_1.cmdLine.maxSize) ||
-            (commandLine_1.cmdLine.maxGzipSize !== undefined && summary.gzipsize > commandLine_1.cmdLine.maxGzipSize);
-        if (overBudget)
-            process.exit(1);
-        return;
-    }
-    if (commandLine_1.cmdLine.maxSize !== undefined && summary.size > commandLine_1.cmdLine.maxSize) {
-        console.error((0, errorMessages_1.getSizeBudgetExceededError)('size', commandLine_1.cmdLine.maxSize, summary.size));
-        process.exit(1);
-    }
-    if (commandLine_1.cmdLine.maxGzipSize !== undefined && summary.gzipsize > commandLine_1.cmdLine.maxGzipSize) {
-        console.error((0, errorMessages_1.getSizeBudgetExceededError)('gzipSize', commandLine_1.cmdLine.maxGzipSize, summary.gzipsize));
-        process.exit(1);
-    }
-    if (commandLine_1.cmdLine.dryRun) {
-        const baseLabel = commandLine_1.cmdLine.basePath || '(none)';
-        const spaLabel = commandLine_1.cmdLine.spa ? 'yes' : 'no';
-        console.log(`[DRY RUN] Engine: ${commandLine_1.cmdLine.engine} | ETag: ${commandLine_1.cmdLine.etag} | Gzip: ${commandLine_1.cmdLine.gzip} | Base: ${baseLabel} | SPA: ${spaLabel}`);
-        console.log(`[DRY RUN] ${summary.filecount} files, ${formatSize(summary.size)} → ${formatSize(summary.gzipsize)} gzip | would write to ${commandLine_1.cmdLine.outputfile}`);
-        console.log('');
-        console.log('[DRY RUN] Routes:');
-        console.log(formatDryRunRoutes(sources, commandLine_1.cmdLine.engine, commandLine_1.cmdLine.basePath, commandLine_1.cmdLine.spa ?? false));
-        return;
-    }
-    const cppFile = (0, cppCode_1.getCppCode)(sources, filesByExtension);
-    (0, node_fs_1.mkdirSync)(node_path_1.default.normalize(node_path_1.default.dirname(commandLine_1.cmdLine.outputfile)), { recursive: true });
-    (0, node_fs_1.writeFileSync)(commandLine_1.cmdLine.outputfile, cppFile, { flush: true, encoding: 'utf8' });
-    console.log(`${summary.filecount} files, ${formatSize(summary.size)} original size, ${formatSize(summary.gzipsize)} gzip size`);
-    console.log(`${commandLine_1.cmdLine.outputfile} ${formatSize(cppFile.length)} size`);
-    if (commandLine_1.cmdLine.manifest) {
-        const manifestPath = node_path_1.default.join(node_path_1.default.dirname(commandLine_1.cmdLine.outputfile), node_path_1.default.basename(commandLine_1.cmdLine.outputfile, node_path_1.default.extname(commandLine_1.cmdLine.outputfile)) + '.manifest.json');
-        const manifest = {
-            generated: new Date().toISOString(),
-            engine: commandLine_1.cmdLine.engine,
-            etag: commandLine_1.cmdLine.etag,
-            gzip: commandLine_1.cmdLine.gzip,
-            filecount: summary.filecount,
-            size: summary.size,
-            gzipSize: summary.gzipsize,
-            files: sources.map((s) => ({
-                path: s.filename,
-                mime: s.mime,
-                size: s.content.length,
-                gzipSize: s.isGzip ? s.contentGzip.length : s.content.length,
-                isGzip: s.isGzip
-            }))
-        };
-        (0, node_fs_1.writeFileSync)(manifestPath, JSON.stringify(manifest, undefined, 2), { encoding: 'utf8' });
-        console.log(`${manifestPath} manifest written`);
-    }
-    if (commandLine_1.cmdLine.engine === 'psychic' || commandLine_1.cmdLine.engine === 'espidf')
-        console.log('\n' + (0, errorMessages_1.getMaxUriHandlersHint)(commandLine_1.cmdLine.engine, sources.length, commandLine_1.cmdLine.espmethod));
 }
-main();
+var pipeline_2 = require("./pipeline");
+Object.defineProperty(exports, "calculateCompressionRatio", { enumerable: true, get: function () { return pipeline_2.calculateCompressionRatio; } });
+Object.defineProperty(exports, "createSourceEntry", { enumerable: true, get: function () { return pipeline_2.createSourceEntry; } });
+Object.defineProperty(exports, "formatAnalyzeTable", { enumerable: true, get: function () { return pipeline_2.formatAnalyzeTable; } });
+Object.defineProperty(exports, "formatChangeSummary", { enumerable: true, get: function () { return pipeline_2.formatChangeSummary; } });
+Object.defineProperty(exports, "formatCompressionLog", { enumerable: true, get: function () { return pipeline_2.formatCompressionLog; } });
+Object.defineProperty(exports, "formatDryRunRoutes", { enumerable: true, get: function () { return pipeline_2.formatDryRunRoutes; } });
+Object.defineProperty(exports, "formatSize", { enumerable: true, get: function () { return pipeline_2.formatSize; } });
+Object.defineProperty(exports, "formatSizePrecise", { enumerable: true, get: function () { return pipeline_2.formatSizePrecise; } });
+Object.defineProperty(exports, "shouldUseGzip", { enumerable: true, get: function () { return pipeline_2.shouldUseGzip; } });
+Object.defineProperty(exports, "updateExtensionGroup", { enumerable: true, get: function () { return pipeline_2.updateExtensionGroup; } });

package/dist/initCommand.d.ts

@@ -0,0 +1,2 @@
+export declare function runInit(): Promise<void>;
+//# sourceMappingURL=initCommand.d.ts.map

package/dist/initCommand.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:readline/promises");
+const RC_FILENAME = '.svelteesp32rc.json';
+const ENGINES = ['psychic', 'async', 'espidf', 'webserver'];
+const TRISTATES = ['always', 'never', 'compiler'];
+function isEngine(value) {
+    return ENGINES.includes(value);
+}
+function isTriState(value) {
+    return TRISTATES.includes(value);
+}
+async function runInit() {
+    const rl = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
+    try {
+        console.log('svelteesp32 init - Create a configuration file\n');
+        const rcPath = node_path_1.default.join(process.cwd(), RC_FILENAME);
+        if ((0, node_fs_1.existsSync)(rcPath)) {
+            const overwriteAnswerRaw = await rl.question(`${RC_FILENAME} already exists. Overwrite? (y/N): `);
+            if (overwriteAnswerRaw.trim().toLowerCase() !== 'y') {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        const engineAnswerRaw = await rl.question(`Engine (${ENGINES.join('|')}) [psychic]: `);
+        const engineAnswer = engineAnswerRaw.trim();
+        const engine = isEngine(engineAnswer) ? engineAnswer : 'psychic';
+        const sourcepathAnswerRaw = await rl.question('Source path (compiled web app dist folder) [./dist]: ');
+        const sourcepath = sourcepathAnswerRaw.trim() || './dist';
+        const outputfileAnswerRaw = await rl.question('Output file (C++ header path) [./svelteesp32.h]: ');
+        const outputfile = outputfileAnswerRaw.trim() || './svelteesp32.h';
+        const etagAnswerRaw = await rl.question(`ETag (${TRISTATES.join('|')}) [always]: `);
+        const etagAnswer = etagAnswerRaw.trim();
+        const etag = isTriState(etagAnswer) ? etagAnswer : 'always';
+        const config = { engine, sourcepath, outputfile, etag, gzip: 'always' };
+        (0, node_fs_1.writeFileSync)(rcPath, JSON.stringify(config, undefined, 2) + '\n', 'utf8');
+        console.log(`\nCreated ${RC_FILENAME}`);
+        const runAnswerRaw = await rl.question('\nWould you like to run svelteesp32 now? (Y/n): ');
+        if (runAnswerRaw.trim().toLowerCase() !== 'n') {
+            const binaryPath = process.argv[1];
+            if (binaryPath)
+                (0, node_child_process_1.spawnSync)('node', [binaryPath], { stdio: 'inherit' });
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,29 @@
+import type { ICopyFilesArguments } from './commandLine';
+import { type CppCodeSource, type CppCodeSources, type ExtensionGroups } from './cppCode';
+type ProcessingSummary = {
+    filecount: number;
+    size: number;
+    gzipsize: number;
+};
+declare const shouldUseGzip: (originalSize: number, compressedSize: number) => boolean;
+declare const calculateCompressionRatio: (originalSize: number, compressedSize: number) => number;
+declare const formatCompressionLog: (filename: string, padding: string, originalSize: number, compressedSize: number, useGzip: boolean) => string;
+declare const formatSize: (bytes: number) => string;
+declare const formatSizePrecise: (bytes: number) => string;
+declare const createSourceEntry: (filename: string, dataname: string, content: Buffer, contentGzip: Buffer, mimeType: string, sha256: string, isGzip: boolean) => CppCodeSource;
+declare const updateExtensionGroup: (filesByExtension: ExtensionGroups, extension: string) => void;
+declare const formatDryRunRoutes: (sources: CppCodeSources, engine: "psychic" | "async" | "espidf" | "webserver", basePath: string, spa: boolean) => string;
+declare const formatAnalyzeTable: (sources: CppCodeSources, summary: ProcessingSummary, maxSize: number | undefined, maxGzipSize: number | undefined) => string;
+export type PreviousManifestFile = {
+    path: string;
+    size: number;
+    sha256?: string;
+};
+export declare class OverBudgetError extends Error {
+    readonly name = "OverBudgetError";
+    constructor();
+}
+declare const formatChangeSummary: (sources: CppCodeSources, previousFiles: PreviousManifestFile[]) => string;
+export declare function runPipeline(options: ICopyFilesArguments): void;
+export { calculateCompressionRatio, createSourceEntry, formatAnalyzeTable, formatChangeSummary, formatCompressionLog, formatDryRunRoutes, formatSize, formatSizePrecise, shouldUseGzip, updateExtensionGroup };
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateExtensionGroup = exports.shouldUseGzip = exports.formatSizePrecise = exports.formatSize = exports.formatDryRunRoutes = exports.formatCompressionLog = exports.formatChangeSummary = exports.formatAnalyzeTable = exports.createSourceEntry = exports.calculateCompressionRatio = exports.OverBudgetError = void 0;
+exports.runPipeline = runPipeline;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = require("node:zlib");
+const mime_types_1 = require("mime-types");
+const consoleColor_1 = require("./consoleColor");
+const cppCode_1 = require("./cppCode");
+const errorMessages_1 = require("./errorMessages");
+const file_1 = require("./file");
+const GZIP_MIN_SIZE = 1024;
+const GZIP_MIN_REDUCTION_RATIO = 0.85;
+const shouldUseGzip = (originalSize, compressedSize) => originalSize > GZIP_MIN_SIZE && compressedSize < originalSize * GZIP_MIN_REDUCTION_RATIO;
+exports.shouldUseGzip = shouldUseGzip;
+const calculateCompressionRatio = (originalSize, compressedSize) => Math.round((compressedSize / originalSize) * 100);
+exports.calculateCompressionRatio = calculateCompressionRatio;
+const formatCompressionLog = (filename, padding, originalSize, compressedSize, useGzip) => {
+    const ratio = calculateCompressionRatio(originalSize, compressedSize);
+    const sizeInfo = `(${originalSize} -> ${compressedSize} = ${ratio}%)`;
+    if (useGzip)
+        return (0, consoleColor_1.greenLog)(` [${filename}] ${padding} ✓ gzip used ${sizeInfo}`);
+    const tooSmall = originalSize <= GZIP_MIN_SIZE ? '(too small) ' : '';
+    return (0, consoleColor_1.yellowLog)(` [${filename}] ${padding} x gzip unused ${tooSmall}${sizeInfo}`);
+};
+exports.formatCompressionLog = formatCompressionLog;
+const formatSize = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    return `${Math.round(bytes / 1024)}kB`;
+};
+exports.formatSize = formatSize;
+const formatSizePrecise = (bytes) => {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    return `${(bytes / 1024).toFixed(1)}kB`;
+};
+exports.formatSizePrecise = formatSizePrecise;
+const createSourceEntry = (filename, dataname, content, contentGzip, mimeType, sha256, isGzip) => ({
+    filename,
+    dataname,
+    datanameUpperCase: dataname.toUpperCase(),
+    content,
+    contentGzip: isGzip ? contentGzip : content,
+    isGzip,
+    mime: mimeType,
+    sha256
+});
+exports.createSourceEntry = createSourceEntry;
+const updateExtensionGroup = (filesByExtension, extension) => {
+    const group = filesByExtension.find((fe) => fe.extension === extension);
+    if (group)
+        group.count += 1;
+    else
+        filesByExtension.push({ extension, count: 1 });
+};
+exports.updateExtensionGroup = updateExtensionGroup;
+const sizeCellFor = (s) => {
+    const orig = formatSize(s.content.length);
+    if (s.isGzip)
+        return `${orig} → ${formatSize(s.contentGzip.length)}`;
+    return orig;
+};
+const formatDryRunRoutes = (sources, engine, basePath, spa) => {
+    if (sources.length === 0)
+        return '  (no files)';
+    const defaultSource = sources.find((s) => s.filename === 'index.html' || s.filename === 'index.htm');
+    const rows = [];
+    if (defaultSource)
+        rows.push({
+            url: basePath || '/',
+            mime: defaultSource.mime,
+            sizeCell: sizeCellFor(defaultSource),
+            tag: '[default]'
+        });
+    for (const source of sources)
+        rows.push({
+            url: `${basePath}/${source.filename}`,
+            mime: source.mime,
+            sizeCell: sizeCellFor(source),
+            tag: source.isGzip ? '' : '[no gzip]'
+        });
+    if (spa && defaultSource) {
+        const spaUrl = engine === 'psychic' && basePath ? `${basePath}/*` : '(SPA catch-all)';
+        rows.push({ url: spaUrl, mime: defaultSource.mime, sizeCell: '', tag: '[SPA catch-all → index.html]' });
+    }
+    const urlWidth = Math.max(...rows.map((r) => r.url.length));
+    const mimeWidth = Math.max(...rows.map((r) => r.mime.length));
+    const sizeWidth = Math.max(...rows.map((r) => r.sizeCell.length));
+    return rows
+        .map((r) => {
+        const tagPart = r.tag ? `  ${r.tag}` : '';
+        return `  GET ${r.url.padEnd(urlWidth)}  ${r.mime.padEnd(mimeWidth)}  ${r.sizeCell.padEnd(sizeWidth)}${tagPart}`.trimEnd();
+    })
+        .join('\n');
+};
+exports.formatDryRunRoutes = formatDryRunRoutes;
+const formatAnalyzeTable = (sources, summary, maxSize, maxGzipSize) => {
+    const rows = sources.map((s) => ({
+        file: s.filename,
+        orig: formatSizePrecise(s.content.length),
+        gzip: formatSizePrecise(s.isGzip ? s.contentGzip.length : s.content.length),
+        tag: s.isGzip ? '' : '[no gzip]'
+    }));
+    const fileWidth = Math.max(4, ...rows.map((r) => r.file.length), 'Total'.length);
+    const origWidth = Math.max(8, ...rows.map((r) => r.orig.length), formatSizePrecise(summary.size).length);
+    const gzipWidth = Math.max(8, ...rows.map((r) => r.gzip.length), formatSizePrecise(summary.gzipsize).length);
+    const separator = `${'─'.repeat(fileWidth)}  ${'─'.repeat(origWidth)}  ${'─'.repeat(gzipWidth)}`;
+    const header = `${'File'.padEnd(fileWidth)}  ${'Original'.padEnd(origWidth)}  ${'Gzip'.padEnd(gzipWidth)}`;
+    const dataRows = rows.map((r) => {
+        const tagPart = r.tag ? `  ${r.tag}` : '';
+        return `${r.file.padEnd(fileWidth)}  ${r.orig.padEnd(origWidth)}  ${r.gzip.padEnd(gzipWidth)}${tagPart}`.trimEnd();
+    });
+    const totalOrig = formatSizePrecise(summary.size);
+    const totalGzip = formatSizePrecise(summary.gzipsize);
+    const totalRow = `${'Total'.padEnd(fileWidth)}  ${totalOrig.padEnd(origWidth)}  ${totalGzip.padEnd(gzipWidth)}`;
+    const lines = [header, separator, ...dataRows, separator, totalRow];
+    if (maxSize !== undefined) {
+        const pass = summary.size <= maxSize;
+        const budgetRow = `${'Budget (maxsize)'.padEnd(fileWidth)}  ${formatSizePrecise(maxSize).padEnd(origWidth)}  ${'-'.padEnd(gzipWidth)}  ${pass ? '✓ PASS' : '✗ FAIL'}`;
+        lines.push(budgetRow);
+    }
+    if (maxGzipSize !== undefined) {
+        const pass = summary.gzipsize <= maxGzipSize;
+        const budgetRow = `${'Budget (maxgzipsize)'.padEnd(fileWidth)}  ${'-'.padEnd(origWidth)}  ${formatSizePrecise(maxGzipSize).padEnd(gzipWidth)}  ${pass ? '✓ PASS' : '✗ FAIL'}`;
+        lines.push(budgetRow);
+    }
+    return lines.join('\n');
+};
+exports.formatAnalyzeTable = formatAnalyzeTable;
+class OverBudgetError extends Error {
+    name = 'OverBudgetError';
+    constructor() {
+        super('Over budget in analyze mode');
+    }
+}
+exports.OverBudgetError = OverBudgetError;
+const formatChangeSummary = (sources, previousFiles) => {
+    const previousMap = new Map(previousFiles.map((f) => [f.path, f]));
+    const currentMap = new Map(sources.map((s) => [s.filename, s]));
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const source of sources) {
+        const previous = previousMap.get(source.filename);
+        if (!previous)
+            added.push(source);
+        else if (previous.sha256 ? previous.sha256 !== source.sha256 : previous.size !== source.content.length)
+            modified.push({ source, previousSize: previous.size });
+    }
+    for (const previous of previousFiles)
+        if (!currentMap.has(previous.path))
+            removed.push(previous);
+    if (added.length === 0 && removed.length === 0 && modified.length === 0)
+        return 'Change summary: (no changes)';
+    const allNames = [
+        ...added.map((s) => s.filename),
+        ...removed.map((f) => f.path),
+        ...modified.map((m) => m.source.filename)
+    ];
+    const nameWidth = Math.max(...allNames.map((n) => n.length));
+    const lines = ['Change summary:'];
+    for (const source of added)
+        lines.push((0, consoleColor_1.greenLog)(`  + ${source.filename.padEnd(nameWidth)}  ${formatSizePrecise(source.content.length)}`));
+    for (const { source, previousSize } of modified)
+        lines.push((0, consoleColor_1.yellowLog)(`  ~ ${source.filename.padEnd(nameWidth)}  ${formatSizePrecise(previousSize)} → ${formatSizePrecise(source.content.length)}`));
+    for (const previous of removed)
+        lines.push((0, consoleColor_1.redLog)(`  - ${previous.path}`));
+    return lines.join('\n');
+};
+exports.formatChangeSummary = formatChangeSummary;
+function runPipeline(options) {
+    const summary = {
+        filecount: 0,
+        size: 0,
+        gzipsize: 0
+    };
+    const sources = [];
+    const filesByExtension = [];
+    console.log('Collecting source files');
+    const files = (0, file_1.getFiles)(options);
+    if (files.size === 0)
+        throw new Error(`Directory ${options.sourcepath} is empty`);
+    if (options.spa && ![...files.keys()].some((f) => f === 'index.html' || f === 'index.htm'))
+        console.warn((0, consoleColor_1.yellowLog)('[SvelteESP32] Warning: --spa is set but no index.html/index.htm found; catch-all will not be generated.'));
+    console.log();
+    console.log('Translation to header file');
+    const longestFilename = [...files.keys()].reduce((p, c) => Math.max(c.length, p), 0);
+    for (const [originalFilename, fileData] of files) {
+        const { content, hash: sha256 } = fileData;
+        const rawMime = (0, mime_types_1.lookup)(originalFilename);
+        if (!rawMime)
+            console.log((0, consoleColor_1.yellowLog)(` [${originalFilename}] unknown MIME type for extension '${node_path_1.default.extname(originalFilename)}', using text/plain`));
+        const mimeType = rawMime || 'text/plain';
+        summary.filecount++;
+        const filename = originalFilename.replace(/\\/g, '/');
+        let dataname = filename.replace(/\W/g, '_');
+        if (/^\d/.test(dataname))
+            dataname = '_' + dataname;
+        let extension = node_path_1.default.extname(filename).toUpperCase();
+        if (extension.startsWith('.'))
+            extension = extension.slice(1);
+        updateExtensionGroup(filesByExtension, extension);
+        summary.size += content.length;
+        const zipContent = (0, node_zlib_1.gzipSync)(content, { level: 9 });
+        const useGzip = shouldUseGzip(content.length, zipContent.length);
+        summary.gzipsize += useGzip ? zipContent.length : content.length;
+        sources.push(createSourceEntry(filename, dataname, content, zipContent, mimeType, sha256, useGzip));
+        const padding = ' '.repeat(longestFilename - originalFilename.length);
+        console.log(formatCompressionLog(originalFilename, padding, content.length, zipContent.length, useGzip));
+    }
+    console.log('');
+    filesByExtension.sort((left, right) => left.extension.localeCompare(right.extension));
+    if (options.analyze) {
+        console.log(formatAnalyzeTable(sources, summary, options.maxSize, options.maxGzipSize));
+        const overBudget = (options.maxSize !== undefined && summary.size > options.maxSize) ||
+            (options.maxGzipSize !== undefined && summary.gzipsize > options.maxGzipSize);
+        if (overBudget)
+            throw new OverBudgetError();
+        return;
+    }
+    if (options.maxSize !== undefined && summary.size > options.maxSize)
+        throw new Error((0, errorMessages_1.getSizeBudgetExceededError)('size', options.maxSize, summary.size));
+    if (options.maxGzipSize !== undefined && summary.gzipsize > options.maxGzipSize)
+        throw new Error((0, errorMessages_1.getSizeBudgetExceededError)('gzipSize', options.maxGzipSize, summary.gzipsize));
+    if (options.dryRun) {
+        const baseLabel = options.basePath || '(none)';
+        const spaLabel = options.spa ? 'yes' : 'no';
+        console.log(`[DRY RUN] Engine: ${options.engine} | ETag: ${options.etag} | Gzip: ${options.gzip} | Base: ${baseLabel} | SPA: ${spaLabel}`);
+        console.log(`[DRY RUN] ${summary.filecount} files, ${formatSize(summary.size)} → ${formatSize(summary.gzipsize)} gzip | would write to ${options.outputfile}`);
+        console.log('');
+        console.log('[DRY RUN] Routes:');
+        console.log(formatDryRunRoutes(sources, options.engine, options.basePath, options.spa ?? false));
+        return;
+    }
+    const cppFile = (0, cppCode_1.getCppCode)(sources, filesByExtension);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.normalize(node_path_1.default.dirname(options.outputfile)), { recursive: true });
+    (0, node_fs_1.writeFileSync)(options.outputfile, cppFile, { flush: true, encoding: 'utf8' });
+    console.log(`${summary.filecount} files, ${formatSize(summary.size)} original size, ${formatSize(summary.gzipsize)} gzip size`);
+    console.log(`${options.outputfile} ${formatSize(cppFile.length)} size`);
+    if (options.manifest) {
+        const manifestPath = node_path_1.default.join(node_path_1.default.dirname(options.outputfile), node_path_1.default.basename(options.outputfile, node_path_1.default.extname(options.outputfile)) + '.manifest.json');
+        let previousManifest;
+        if ((0, node_fs_1.existsSync)(manifestPath))
+            try {
+                previousManifest = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, 'utf8'));
+            }
+            catch {
+            }
+        const manifest = {
+            generated: new Date().toISOString(),
+            engine: options.engine,
+            etag: options.etag,
+            gzip: options.gzip,
+            filecount: summary.filecount,
+            size: summary.size,
+            gzipSize: summary.gzipsize,
+            files: sources.map((s) => ({
+                path: s.filename,
+                mime: s.mime,
+                size: s.content.length,
+                gzipSize: s.isGzip ? s.contentGzip.length : s.content.length,
+                isGzip: s.isGzip,
+                sha256: s.sha256
+            }))
+        };
+        (0, node_fs_1.writeFileSync)(manifestPath, JSON.stringify(manifest, undefined, 2), { encoding: 'utf8' });
+        console.log(`${manifestPath} manifest written`);
+        if (previousManifest)
+            console.log(formatChangeSummary(sources, previousManifest.files));
+    }
+    if (options.engine === 'psychic' || options.engine === 'espidf')
+        console.log('\n' + (0, errorMessages_1.getMaxUriHandlersHint)(options.engine, sources.length, options.espmethod));
+}

package/dist/vitePlugin.d.ts

@@ -0,0 +1,34 @@
+interface ResolvedViteConfig {
+    build: {
+        outDir: string;
+    };
+}
+interface VitePlugin {
+    name: string;
+    configResolved: (config: ResolvedViteConfig) => void;
+    closeBundle: () => void;
+}
+export interface SvelteESP32PluginOptions {
+    output: string;
+    sourcepath?: string;
+    engine?: 'psychic' | 'async' | 'espidf' | 'webserver';
+    etag?: 'always' | 'never' | 'compiler';
+    gzip?: 'always' | 'never' | 'compiler';
+    cachetime?: number;
+    cachetimeHtml?: number;
+    cachetimeAssets?: number;
+    exclude?: string[];
+    basepath?: string;
+    espmethod?: string;
+    define?: string;
+    version?: string;
+    created?: boolean;
+    spa?: boolean;
+    manifest?: boolean;
+    noIndexCheck?: boolean;
+    maxSize?: number;
+    maxGzipSize?: number;
+}
+export declare function svelteESP32(options: SvelteESP32PluginOptions): VitePlugin;
+export {};
+//# sourceMappingURL=vitePlugin.d.ts.map