svelteesp32 1.9.3 → 1.10.0

package/README.md

@@ -12,6 +12,8 @@ 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.10.0, we reduced npm dependencies
+
 > Starting with version v1.9.0, code generator for esp-idf is available
 
 > Starting with version v1.8.0, use the new and maintained ESPAsyncWebserver available at https://github.com/ESP32Async/ESPAsyncWebServer

package/dist/commandLine.js

@@ -2,91 +2,184 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdLine = void 0;
 const node_fs_1 = require("node:fs");
-const ts_command_line_args_1 = require("ts-command-line-args");
-exports.cmdLine = (0, ts_command_line_args_1.parse)({
-    engine: {
-        type: (value) => {
-            if (value === 'psychic')
-                return 'psychic';
-            if (value === 'psychic2')
-                return 'psychic2';
-            if (value === 'async')
-                return 'async';
-            if (value === 'espidf')
-                return 'espidf';
-            throw new Error(`Invalid engine: ${value}`);
-        },
-        alias: 'e',
-        description: 'The engine for which the include file is created (psychic|psychic2|async)',
-        defaultValue: 'psychic'
-    },
-    sourcepath: {
-        type: String,
-        alias: 's',
-        description: 'Source dist folder contains compiled web files'
-    },
-    outputfile: {
-        type: String,
-        alias: 'o',
-        description: 'Generated output file with path',
-        defaultValue: 'svelteesp32.h'
-    },
-    etag: {
-        type: (value) => {
-            if (value === 'true')
-                return 'true';
-            if (value === 'false')
-                return 'false';
-            if (value === 'compiler')
-                return 'compiler';
-            throw new Error(`Invalid etag: ${value}`);
-        },
-        description: 'Use ETAG header for cache',
-        defaultValue: 'false'
-    },
-    gzip: {
-        type: (value) => {
-            if (value === 'true')
-                return 'true';
-            if (value === 'false')
-                return 'false';
-            if (value === 'compiler')
-                return 'compiler';
-            throw new Error(`Invalid etag: ${value}`);
-        },
-        description: 'Compress content with gzip',
-        defaultValue: 'true'
-    },
-    created: {
-        type: Boolean,
-        description: 'Include creation time in the output file',
-        defaultValue: false
-    },
-    version: {
-        type: String,
-        description: 'Include version info in the output file',
-        defaultValue: ''
-    },
-    espmethod: {
-        type: String,
-        description: 'Name of generated method',
-        defaultValue: 'initSvelteStaticFiles'
-    },
-    define: {
-        type: String,
-        description: 'Prefix of c++ defines',
-        defaultValue: 'SVELTEESP32'
-    },
-    cachetime: {
-        type: Number,
-        description: 'max-age cache time in seconds',
-        defaultValue: 0
-    },
-    help: { type: Boolean, optional: true, alias: 'h', description: 'Shows this help' }
-}, {
-    helpArg: 'help',
-    headerContentSections: [{ header: 'svelteesp32', content: 'Svelte JS to ESP32 converter' }]
-});
+function showHelp() {
+    console.log(`
+svelteesp32 - Svelte JS to ESP32 converter
+
+Options:
+  -e, --engine <value>       The engine for which the include file is created
+                             (psychic|psychic2|async|espidf) (default: "psychic")
+  -s, --sourcepath <path>    Source dist folder contains compiled web files (required)
+  -o, --outputfile <path>    Generated output file with path (default: "svelteesp32.h")
+  --etag <value>             Use ETAG header for cache (true|false|compiler) (default: "false")
+  --gzip <value>             Compress content with gzip (true|false|compiler) (default: "true")
+  --created                  Include creation time in the output file (default: false)
+  --version <value>          Include version info in the output file (default: "")
+  --espmethod <name>         Name of generated method (default: "initSvelteStaticFiles")
+  --define <prefix>          Prefix of c++ defines (default: "SVELTEESP32")
+  --cachetime <seconds>      max-age cache time in seconds (default: 0)
+  -h, --help                 Shows this help
+`);
+    process.exit(0);
+}
+function validateEngine(value) {
+    if (value === 'psychic' || value === 'psychic2' || value === 'async' || value === 'espidf')
+        return value;
+    throw new Error(`Invalid engine: ${value}`);
+}
+function validateTriState(value, name) {
+    if (value === 'true' || value === 'false' || value === 'compiler')
+        return value;
+    throw new Error(`Invalid ${name}: ${value}`);
+}
+function parseArguments() {
+    const arguments_ = process.argv.slice(2);
+    const result = {
+        engine: 'psychic',
+        outputfile: 'svelteesp32.h',
+        etag: 'false',
+        gzip: 'true',
+        created: false,
+        version: '',
+        espmethod: 'initSvelteStaticFiles',
+        define: 'SVELTEESP32',
+        cachetime: 0
+    };
+    for (let index = 0; index < arguments_.length; index++) {
+        const argument = arguments_[index];
+        if (!argument)
+            continue;
+        if (argument === '--help' || argument === '-h')
+            showHelp();
+        if (argument.startsWith('--') && argument.includes('=')) {
+            const parts = argument.split('=');
+            const flag = parts[0];
+            const value = parts.slice(1).join('=');
+            if (!flag || !value)
+                throw new Error(`Invalid argument format: ${argument}`);
+            const flagName = flag.slice(2);
+            switch (flagName) {
+                case 'engine':
+                    result.engine = validateEngine(value);
+                    break;
+                case 'sourcepath':
+                    result.sourcepath = value;
+                    break;
+                case 'outputfile':
+                    result.outputfile = value;
+                    break;
+                case 'etag':
+                    result.etag = validateTriState(value, 'etag');
+                    break;
+                case 'gzip':
+                    result.gzip = validateTriState(value, 'gzip');
+                    break;
+                case 'version':
+                    result.version = value;
+                    break;
+                case 'espmethod':
+                    result.espmethod = value;
+                    break;
+                case 'define':
+                    result.define = value;
+                    break;
+                case 'cachetime':
+                    result.cachetime = Number.parseInt(value, 10);
+                    if (Number.isNaN(result.cachetime)) {
+                        throw new TypeError(`Invalid cachetime: ${value}`);
+                    }
+                    break;
+                default:
+                    throw new Error(`Unknown flag: ${flag}`);
+            }
+            continue;
+        }
+        if (argument === '--created') {
+            result.created = true;
+            continue;
+        }
+        if (argument.startsWith('-') && !argument.startsWith('--')) {
+            const flag = argument.slice(1);
+            const nextArgument = arguments_[index + 1];
+            if (!nextArgument || nextArgument.startsWith('-'))
+                throw new Error(`Missing value for flag: ${argument}`);
+            switch (flag) {
+                case 'e':
+                    result.engine = validateEngine(nextArgument);
+                    index++;
+                    break;
+                case 's':
+                    result.sourcepath = nextArgument;
+                    index++;
+                    break;
+                case 'o':
+                    result.outputfile = nextArgument;
+                    index++;
+                    break;
+                default:
+                    throw new Error(`Unknown flag: ${argument}`);
+            }
+            continue;
+        }
+        if (argument.startsWith('--')) {
+            const flag = argument.slice(2);
+            const nextArgument = arguments_[index + 1];
+            if (!nextArgument || nextArgument.startsWith('-'))
+                throw new Error(`Missing value for flag: ${argument}`);
+            switch (flag) {
+                case 'engine':
+                    result.engine = validateEngine(nextArgument);
+                    index++;
+                    break;
+                case 'sourcepath':
+                    result.sourcepath = nextArgument;
+                    index++;
+                    break;
+                case 'outputfile':
+                    result.outputfile = nextArgument;
+                    index++;
+                    break;
+                case 'etag':
+                    result.etag = validateTriState(nextArgument, 'etag');
+                    index++;
+                    break;
+                case 'gzip':
+                    result.gzip = validateTriState(nextArgument, 'gzip');
+                    index++;
+                    break;
+                case 'version':
+                    result.version = nextArgument;
+                    index++;
+                    break;
+                case 'espmethod':
+                    result.espmethod = nextArgument;
+                    index++;
+                    break;
+                case 'define':
+                    result.define = nextArgument;
+                    index++;
+                    break;
+                case 'cachetime':
+                    result.cachetime = Number.parseInt(nextArgument, 10);
+                    if (Number.isNaN(result.cachetime)) {
+                        throw new TypeError(`Invalid cachetime: ${nextArgument}`);
+                    }
+                    index++;
+                    break;
+                default:
+                    throw new Error(`Unknown flag: --${flag}`);
+            }
+            continue;
+        }
+        throw new Error(`Unknown argument: ${argument}`);
+    }
+    if (!result.sourcepath) {
+        console.error('Error: --sourcepath is required');
+        showHelp();
+    }
+    return result;
+}
+exports.cmdLine = parseArguments();
 if (!(0, node_fs_1.existsSync)(exports.cmdLine.sourcepath) || !(0, node_fs_1.statSync)(exports.cmdLine.sourcepath).isDirectory()) {
     console.error(`Directory ${exports.cmdLine.sourcepath} not exists or not a directory`);
     process.exit(1);

package/dist/file.js

@@ -7,7 +7,7 @@ exports.getFiles = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
-const glob_1 = require("glob");
+const tinyglobby_1 = require("tinyglobby");
 const commandLine_1 = require("./commandLine");
 const consoleColor_1 = require("./consoleColor");
 const findSimilarFiles = (files) => {
@@ -43,7 +43,7 @@ const shouldSkipFile = (filename, allFilenames) => {
     return false;
 };
 const getFiles = () => {
-    const allFilenames = (0, glob_1.globSync)('**/*', { cwd: commandLine_1.cmdLine.sourcepath, nodir: true });
+    const allFilenames = (0, tinyglobby_1.globSync)('**/*', { cwd: commandLine_1.cmdLine.sourcepath, onlyFiles: true, dot: false });
     const filenames = allFilenames.filter((filename) => !shouldSkipFile(filename, allFilenames));
     const result = new Map();
     for (const filename of filenames) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelteesp32",
-  "version": "1.9.3",
+  "version": "1.10.0",
   "description": "Convert Svelte (or any frontend) JS application to serve it from ESP32 webserver (PsychicHttp)",
   "author": "BCsabaEngine",
   "license": "ISC",
@@ -58,23 +58,23 @@
   ],
   "devDependencies": {
     "@types/mime-types": "^3.0.1",
-    "@types/node": "^24.9.2",
-    "@typescript-eslint/eslint-plugin": "^8.46.2",
-    "@typescript-eslint/parser": "^8.46.2",
-    "eslint": "^9.39.0",
+    "@types/node": "^24.10.1",
+    "@types/picomatch": "^4.0.2",
+    "@typescript-eslint/eslint-plugin": "^8.47.0",
+    "@typescript-eslint/parser": "^8.47.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unicorn": "^62.0.0",
-    "nodemon": "^3.1.10",
+    "nodemon": "^3.1.11",
     "prettier": "^3.6.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "glob": "^11.0.3",
     "handlebars": "^4.7.8",
-    "mime-types": "^3.0.1",
-    "ts-command-line-args": "^2.5.1"
+    "mime-types": "^3.0.2",
+    "tinyglobby": "^0.2.15"
   }
 }