svelteesp32 1.12.1 → 1.13.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.13.0, RC files support npm package variable interpolation
+
 > 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
@@ -540,6 +542,89 @@ To keep defaults, explicitly list them in your RC file:
 }
 ```
 
+#### NPM Package Variable Interpolation
+
+RC files support automatic variable interpolation from your `package.json`. This allows you to reference package.json fields in your RC configuration using npm-style variable syntax.
+
+**Syntax:** `$npm_package_<field_name>`
+
+**Supported in:** All string fields (`version`, `define`, `sourcepath`, `outputfile`, `espmethod`, `exclude` patterns)
+
+**Example:**
+
+```json
+// .svelteesp32rc.json
+{
+  "engine": "psychic",
+  "version": "v$npm_package_version",
+  "define": "$npm_package_name",
+  "sourcepath": "./dist",
+  "outputfile": "./output.h"
+}
+```
+
+With `package.json` containing:
+
+```json
+{
+  "name": "my-esp32-app",
+  "version": "2.1.0"
+}
+```
+
+The variables are automatically interpolated to:
+
+```json
+{
+  "version": "v2.1.0",
+  "define": "my_esp32_app"
+}
+```
+
+**Nested Fields:**
+
+You can access nested package.json fields using underscores:
+
+```json
+// package.json
+{
+  "name": "myapp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/user/repo.git"
+  }
+}
+
+// .svelteesp32rc.json
+{
+  "version": "$npm_package_repository_type"
+}
+// Results in: "version": "git"
+```
+
+**Multiple Variables:**
+
+Combine multiple variables in a single field:
+
+```json
+{
+  "version": "$npm_package_name-v$npm_package_version-release"
+}
+// Results in: "my-esp32-app-v2.1.0-release"
+```
+
+**Requirements:**
+
+- `package.json` must exist in the same directory as the RC file
+- If variables are used but `package.json` is not found, an error is thrown with details about which fields contain variables
+- Unknown variables are left unchanged (e.g., `$npm_package_nonexistent` stays as-is)
+
+**Use Cases:**
+
+- **Version Synchronization:** Keep header version in sync with npm package version
+- **Dynamic Naming:** Use package name for C++ defines automatically
+- **CI/CD Integration:** Reusable RC files across projects with different package names
+
 ### 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.d.ts

@@ -12,6 +12,22 @@ interface ICopyFilesArguments {
     exclude: string[];
     help?: boolean;
 }
+interface IRcFileConfig {
+    engine?: 'psychic' | 'psychic2' | 'async' | 'espidf';
+    sourcepath?: string;
+    outputfile?: string;
+    espmethod?: string;
+    define?: string;
+    gzip?: 'true' | 'false' | 'compiler';
+    etag?: 'true' | 'false' | 'compiler';
+    cachetime?: number;
+    created?: boolean;
+    version?: string;
+    exclude?: string[];
+}
+declare function getNpmPackageVariable(packageJson: Record<string, unknown>, variableName: string): string | undefined;
+declare function hasNpmVariables(config: IRcFileConfig): boolean;
+declare function interpolateNpmVariables(config: IRcFileConfig, rcFilePath: string): IRcFileConfig;
+export { getNpmPackageVariable, hasNpmVariables, interpolateNpmVariables };
 export declare function formatConfiguration(cmdLine: ICopyFilesArguments): string;
 export declare const cmdLine: ICopyFilesArguments;
-export {};

package/dist/commandLine.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdLine = void 0;
+exports.getNpmPackageVariable = getNpmPackageVariable;
+exports.hasNpmVariables = hasNpmVariables;
+exports.interpolateNpmVariables = interpolateNpmVariables;
 exports.formatConfiguration = formatConfiguration;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -90,11 +93,100 @@ function findRcFile(customConfigPath) {
     }
     return undefined;
 }
+function findPackageJson(rcFilePath) {
+    const rcDirectory = node_path_1.default.dirname(rcFilePath);
+    const packageJsonPath = node_path_1.default.join(rcDirectory, 'package.json');
+    return (0, node_fs_1.existsSync)(packageJsonPath) ? packageJsonPath : undefined;
+}
+function parsePackageJson(packageJsonPath) {
+    try {
+        const content = (0, node_fs_1.readFileSync)(packageJsonPath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse package.json at ${packageJsonPath}: ${error.message}`);
+    }
+}
+function getNpmPackageVariable(packageJson, variableName) {
+    const prefix = '$npm_package_';
+    if (!variableName.startsWith(prefix))
+        return undefined;
+    const pathString = variableName.slice(prefix.length);
+    const pathSegments = pathString.split('_');
+    let current = packageJson;
+    for (const segment of pathSegments) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    if (current === null || current === undefined)
+        return undefined;
+    return String(current);
+}
+function checkStringForNpmVariable(value) {
+    return value?.includes('$npm_package_') ?? false;
+}
+function hasNpmVariables(config) {
+    return (checkStringForNpmVariable(config.sourcepath) ||
+        checkStringForNpmVariable(config.outputfile) ||
+        checkStringForNpmVariable(config.espmethod) ||
+        checkStringForNpmVariable(config.define) ||
+        checkStringForNpmVariable(config.version) ||
+        (Array.isArray(config.exclude) && config.exclude.some((pattern) => checkStringForNpmVariable(pattern))) ||
+        false);
+}
+function interpolateNpmVariables(config, rcFilePath) {
+    if (!hasNpmVariables(config))
+        return config;
+    const packageJsonPath = findPackageJson(rcFilePath);
+    if (!packageJsonPath) {
+        const affectedFields = [];
+        if (config.sourcepath?.includes('$npm_package_'))
+            affectedFields.push('sourcepath');
+        if (config.outputfile?.includes('$npm_package_'))
+            affectedFields.push('outputfile');
+        if (config.version?.includes('$npm_package_'))
+            affectedFields.push('version');
+        if (config.espmethod?.includes('$npm_package_'))
+            affectedFields.push('espmethod');
+        if (config.define?.includes('$npm_package_'))
+            affectedFields.push('define');
+        if (config.exclude)
+            for (const [index, pattern] of config.exclude.entries())
+                if (pattern.includes('$npm_package_'))
+                    affectedFields.push(`exclude[${index}]`);
+        throw new Error(`RC file uses npm package variables but package.json not found in ${node_path_1.default.dirname(rcFilePath)}\n` +
+            `Variables found in fields: ${affectedFields.join(', ')}\n` +
+            `Please ensure package.json exists in the same directory as your RC file.`);
+    }
+    const packageJson = parsePackageJson(packageJsonPath);
+    const interpolateString = (value) => {
+        const regex = /\$npm_package_[\dA-Za-z]+(?:_[a-z][\dA-Za-z]*)*/g;
+        return value.replace(regex, (match) => getNpmPackageVariable(packageJson, match) ?? match);
+    };
+    const result = { ...config };
+    if (result.sourcepath)
+        result.sourcepath = interpolateString(result.sourcepath);
+    if (result.outputfile)
+        result.outputfile = interpolateString(result.outputfile);
+    if (result.espmethod)
+        result.espmethod = interpolateString(result.espmethod);
+    if (result.define)
+        result.define = interpolateString(result.define);
+    if (result.version)
+        result.version = interpolateString(result.version);
+    if (result.exclude)
+        result.exclude = result.exclude.map((pattern) => interpolateString(pattern));
+    return result;
+}
 function loadRcFile(rcPath) {
     try {
         const content = (0, node_fs_1.readFileSync)(rcPath, 'utf8');
         const config = JSON.parse(content);
-        return validateRcConfig(config, rcPath);
+        const interpolatedConfig = interpolateNpmVariables(config, rcPath);
+        return validateRcConfig(interpolatedConfig, rcPath);
     }
     catch (error) {
         if (error instanceof SyntaxError)

package/package.json

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