svelteesp32 1.11.0 → 1.12.0

package/README.md

@@ -12,6 +12,10 @@ In order to be able to easily update OTA, it is important - from the users' poin
 
 This npm package provides a solution for **inserting any JS client application into the ESP web server** (PsychicHttp and also ESPAsyncWebServer (https://github.com/ESP32Async/ESPAsyncWebServer) and ESP-IDF available, PsychicHttp is the default). For this, JS, html, css, font, assets, etc. files must be converted to binary byte array. Npm mode is easy to use and easy to **integrate into your CI/CD pipeline**.
 
+> Starting with version v1.12.0, you can use RC file for configuration
+
+> Starting with version v1.11.0, you can exclude files by pattern
+
 > Starting with version v1.10.0, we reduced npm dependencies
 
 > Starting with version v1.9.0, code generator for esp-idf is available
@@ -84,13 +88,13 @@ npm run fix
 
 ### Usage
 
-**Install package** as devDependency (it is practical if the package is part of the project so that you always receive updates)
+**Install package** as dev dependency (it is practical if the package is part of the project so that you always receive updates)
 
 ```bash
 npm install -D svelteesp32
 ```
 
-After a successful Svelte build (rollup/webpack/vite) **create an includeable c++ header** file
+After a successful Svelte build (rollup/webpack/vite) **create an includable c++ header** file
 
 ```bash
 // for PsychicHttpServer
@@ -425,8 +429,117 @@ You can use the following c++ directives at the project level if you want to con
 | `--version`   | Include a version string in generated header, e.g. `--version=v$npm_package_version` | ''                      |
 | `--espmethod` | Name of generated initialization method                                              | `initSvelteStaticFiles` |
 | `--define`    | Prefix of c++ defines (e.g., SVELTEESP32_COUNT)                                      | `SVELTEESP32`           |
+| `--config`    | Use custom RC file path                                                              | `.svelteesp32rc.json`   |
 | `-h`          | Show help                                                                            |                         |
 
+### Configuration File
+
+You can store frequently-used options in a configuration file to avoid repeating command line arguments. This is especially useful for CI/CD pipelines and team collaboration.
+
+#### Quick Start
+
+Create `.svelteesp32rc.json` in your project directory:
+
+```json
+{
+  "engine": "psychic",
+  "sourcepath": "./dist",
+  "outputfile": "./esp32/include/svelteesp32.h",
+  "etag": "true",
+  "gzip": "true",
+  "cachetime": 86400,
+  "exclude": ["*.map", "*.md"]
+}
+```
+
+Then simply run:
+
+```bash
+npx svelteesp32
+```
+
+No command line arguments needed!
+
+#### Search Locations
+
+The tool automatically searches for `.svelteesp32rc.json` in:
+
+1. Current working directory
+2. User home directory
+
+Or specify a custom location:
+
+```bash
+npx svelteesp32 --config=.svelteesp32rc.prod.json
+```
+
+#### Configuration Reference
+
+All CLI options can be specified in the RC file using long-form property names:
+
+| RC Property  | CLI Flag      | Type    | Example                                          |
+| ------------ | ------------- | ------- | ------------------------------------------------ |
+| `engine`     | `-e`          | string  | `"psychic"`, `"psychic2"`, `"async"`, `"espidf"` |
+| `sourcepath` | `-s`          | string  | `"./dist"`                                       |
+| `outputfile` | `-o`          | string  | `"./output.h"`                                   |
+| `etag`       | `--etag`      | string  | `"true"`, `"false"`, `"compiler"`                |
+| `gzip`       | `--gzip`      | string  | `"true"`, `"false"`, `"compiler"`                |
+| `cachetime`  | `--cachetime` | number  | `86400`                                          |
+| `created`    | `--created`   | boolean | `true`, `false`                                  |
+| `version`    | `--version`   | string  | `"v1.0.0"`                                       |
+| `espmethod`  | `--espmethod` | string  | `"initSvelteStaticFiles"`                        |
+| `define`     | `--define`    | string  | `"SVELTEESP32"`                                  |
+| `exclude`    | `--exclude`   | array   | `["*.map", "*.md"]`                              |
+
+#### CLI Override
+
+Command line arguments always take precedence over RC file values:
+
+```bash
+# Use RC settings but override etag
+npx svelteesp32 --etag=false
+
+# Use RC settings but add different exclude pattern
+npx svelteesp32 --exclude="*.txt"
+```
+
+#### Multiple Environments
+
+Create different config files for different environments:
+
+```bash
+# Development build
+npx svelteesp32 --config=.svelteesp32rc.dev.json
+
+# Production build
+npx svelteesp32 --config=.svelteesp32rc.prod.json
+```
+
+#### Exclude Pattern Behavior
+
+**Replace mode**: When you specify `exclude` patterns in RC file or CLI, they completely replace the defaults.
+
+- **No exclude specified**: Uses default system exclusions (`.DS_Store`, `Thumbs.db`, `.git`, etc.)
+- **RC file has exclude**: Replaces defaults with RC patterns
+- **CLI has --exclude**: Replaces RC patterns (or defaults if no RC)
+
+Example:
+
+```json
+// .svelteesp32rc.json
+{ "exclude": ["*.map"] }
+```
+
+Result: Only `*.map` is excluded (default patterns are replaced)
+
+To keep defaults, explicitly list them in your RC file:
+
+```json
+{
+  "exclude": [".DS_Store", "Thumbs.db", ".git", "*.map", "*.md"]
+}
+```
+
 ### Q&A
 
 - **How big a frontend application can be placed?** If you compress the content with gzip, even a 3-4Mb assets directory can be placed. This is a serious enough amount to serve a complete application.

package/dist/commandLine.js

@@ -1,11 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdLine = void 0;
 const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const consoleColor_1 = require("./consoleColor");
 function showHelp() {
     console.log(`
 svelteesp32 - Svelte JS to ESP32 converter
 
+Configuration:
+  --config <path>            Use custom RC file (default: search for .svelteesp32rc.json)
+
 Options:
   -e, --engine <value>       The engine for which the include file is created
                              (psychic|psychic2|async|espidf) (default: "psychic")
@@ -21,6 +30,23 @@ Options:
   --exclude <pattern>        Exclude files matching glob pattern (repeatable or comma-separated)
                              Examples: --exclude="*.map" --exclude="test/**/*.ts"
   -h, --help                 Shows this help
+
+RC File:
+  The tool searches for .svelteesp32rc.json in:
+    1. Current directory (./.svelteesp32rc.json)
+    2. User home directory (~/.svelteesp32rc.json)
+
+  Example RC file (all fields optional):
+    {
+      "engine": "psychic",
+      "sourcepath": "./dist",
+      "outputfile": "./output.h",
+      "etag": "true",
+      "gzip": "true",
+      "exclude": ["*.map", "*.md"]
+    }
+
+  CLI arguments override RC file values.
 `);
     process.exit(0);
 }
@@ -44,8 +70,95 @@ const DEFAULT_EXCLUDE_PATTERNS = [
     '.gitignore',
     '.gitattributes'
 ];
+function findRcFile(customConfigPath) {
+    if (customConfigPath) {
+        if ((0, node_fs_1.existsSync)(customConfigPath))
+            return customConfigPath;
+        throw new Error(`Config file not found: ${customConfigPath}`);
+    }
+    for (const filename of ['.svelteesp32rc.json', '.svelteesp32rc']) {
+        const cwdPath = node_path_1.default.join(process.cwd(), filename);
+        if ((0, node_fs_1.existsSync)(cwdPath))
+            return cwdPath;
+    }
+    const homeDirectory = (0, node_os_1.homedir)();
+    for (const filename of ['.svelteesp32rc.json', '.svelteesp32rc']) {
+        const homePath = node_path_1.default.join(homeDirectory, filename);
+        if ((0, node_fs_1.existsSync)(homePath))
+            return homePath;
+    }
+    return undefined;
+}
+function loadRcFile(rcPath) {
+    try {
+        const content = (0, node_fs_1.readFileSync)(rcPath, 'utf8');
+        const config = JSON.parse(content);
+        return validateRcConfig(config, rcPath);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON in RC file ${rcPath}: ${error.message}`);
+        throw error;
+    }
+}
+function validateRcConfig(config, rcPath) {
+    if (typeof config !== 'object' || config === null)
+        throw new Error(`RC file ${rcPath} must contain a JSON object`);
+    const configObject = config;
+    const validKeys = new Set([
+        'engine',
+        'sourcepath',
+        'outputfile',
+        'espmethod',
+        'define',
+        'gzip',
+        'etag',
+        'cachetime',
+        'created',
+        'version',
+        'exclude'
+    ]);
+    for (const key of Object.keys(configObject))
+        if (!validKeys.has(key))
+            console.warn((0, consoleColor_1.yellowLog)(`Warning: Unknown property '${key}' in RC file ${rcPath}`));
+    if (configObject['engine'] !== undefined)
+        configObject['engine'] = validateEngine(configObject['engine']);
+    if (configObject['etag'] !== undefined)
+        configObject['etag'] = validateTriState(configObject['etag'], 'etag');
+    if (configObject['gzip'] !== undefined)
+        configObject['gzip'] = validateTriState(configObject['gzip'], 'gzip');
+    if (configObject['cachetime'] !== undefined &&
+        (typeof configObject['cachetime'] !== 'number' || Number.isNaN(configObject['cachetime'])))
+        throw new TypeError(`Invalid cachetime in RC file: ${configObject['cachetime']}`);
+    if (configObject['exclude'] !== undefined) {
+        if (!Array.isArray(configObject['exclude']))
+            throw new TypeError("'exclude' in RC file must be an array");
+        for (const pattern of configObject['exclude'])
+            if (typeof pattern !== 'string')
+                throw new TypeError('All exclude patterns must be strings');
+    }
+    return configObject;
+}
 function parseArguments() {
     const arguments_ = process.argv.slice(2);
+    let customConfigPath;
+    for (let index = 0; index < arguments_.length; index++) {
+        const argument = arguments_[index];
+        if (!argument)
+            continue;
+        if (argument === '--config' && arguments_[index + 1]) {
+            customConfigPath = arguments_[index + 1];
+            break;
+        }
+        if (argument.startsWith('--config=')) {
+            customConfigPath = argument.slice('--config='.length);
+            break;
+        }
+    }
+    const rcPath = findRcFile(customConfigPath);
+    const rcConfig = rcPath ? loadRcFile(rcPath) : {};
+    if (rcPath)
+        console.log((0, consoleColor_1.cyanLog)(`[SvelteESP32] Using config from: ${rcPath}`));
     const result = {
         engine: 'psychic',
         outputfile: 'svelteesp32.h',
@@ -58,6 +171,29 @@ function parseArguments() {
         cachetime: 0,
         exclude: [...DEFAULT_EXCLUDE_PATTERNS]
     };
+    if (rcConfig.engine)
+        result.engine = rcConfig.engine;
+    if (rcConfig.sourcepath)
+        result.sourcepath = rcConfig.sourcepath;
+    if (rcConfig.outputfile)
+        result.outputfile = rcConfig.outputfile;
+    if (rcConfig.etag)
+        result.etag = rcConfig.etag;
+    if (rcConfig.gzip)
+        result.gzip = rcConfig.gzip;
+    if (rcConfig.cachetime !== undefined)
+        result.cachetime = rcConfig.cachetime;
+    if (rcConfig.created !== undefined)
+        result.created = rcConfig.created;
+    if (rcConfig.version)
+        result.version = rcConfig.version;
+    if (rcConfig.espmethod)
+        result.espmethod = rcConfig.espmethod;
+    if (rcConfig.define)
+        result.define = rcConfig.define;
+    if (rcConfig.exclude && rcConfig.exclude.length > 0)
+        result.exclude = [...rcConfig.exclude];
+    const cliExclude = [];
     for (let index = 0; index < arguments_.length; index++) {
         const argument = arguments_[index];
         if (!argument)
@@ -72,6 +208,8 @@ function parseArguments() {
                 throw new Error(`Invalid argument format: ${argument}`);
             const flagName = flag.slice(2);
             switch (flagName) {
+                case 'config':
+                    break;
                 case 'engine':
                     result.engine = validateEngine(value);
                     break;
@@ -106,8 +244,7 @@ function parseArguments() {
                         .split(',')
                         .map((p) => p.trim())
                         .filter(Boolean);
-                    result.exclude = result.exclude || [...DEFAULT_EXCLUDE_PATTERNS];
-                    result.exclude.push(...patterns);
+                    cliExclude.push(...patterns);
                     break;
                 }
                 default:
@@ -148,6 +285,9 @@ function parseArguments() {
             if (!nextArgument || nextArgument.startsWith('-'))
                 throw new Error(`Missing value for flag: ${argument}`);
             switch (flag) {
+                case 'config':
+                    index++;
+                    break;
                 case 'engine':
                     result.engine = validateEngine(nextArgument);
                     index++;
@@ -191,8 +331,7 @@ function parseArguments() {
                         .split(',')
                         .map((p) => p.trim())
                         .filter(Boolean);
-                    result.exclude = result.exclude || [...DEFAULT_EXCLUDE_PATTERNS];
-                    result.exclude.push(...patterns);
+                    cliExclude.push(...patterns);
                     index++;
                     break;
                 }
@@ -203,8 +342,10 @@ function parseArguments() {
         }
         throw new Error(`Unknown argument: ${argument}`);
     }
+    if (cliExclude.length > 0)
+        result.exclude = [...cliExclude];
     if (!result.sourcepath) {
-        console.error('Error: --sourcepath is required');
+        console.error('Error: --sourcepath is required (can be specified in RC file or CLI)');
         showHelp();
     }
     return result;

package/dist/file.js

@@ -63,12 +63,12 @@ const getFiles = () => {
         return true;
     });
     if (excludedFiles.length > 0) {
-        console.log((0, consoleColor_1.cyanLog)(`\n Excluded ${excludedFiles.length} file(s):`));
+        console.log(`\nExcluded ${excludedFiles.length} file(s):`);
         const displayLimit = 10;
         for (const file of excludedFiles.slice(0, displayLimit))
-            console.log((0, consoleColor_1.cyanLog)(`  - ${file}`));
+            console.log((0, consoleColor_1.cyanLog)(`- ${file}`));
         if (excludedFiles.length > displayLimit)
-            console.log((0, consoleColor_1.cyanLog)(`  ... and ${excludedFiles.length - displayLimit} more`));
+            console.log((0, consoleColor_1.cyanLog)(`... and ${excludedFiles.length - displayLimit} more`));
         console.log();
     }
     const result = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelteesp32",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Convert Svelte (or any frontend) JS application to serve it from ESP32 webserver (PsychicHttp)",
   "author": "BCsabaEngine",
   "license": "ISC",