jizy-packer 2.0.5 → 2.1.0

package/README.md

@@ -1,2 +1,120 @@
+
 # jizy-packer
-Build a CLI app to generate optimized builds.
+
+A CLI tool and Node.js library to generate optimized builds for your projects. It provides utilities for configuration management, build orchestration, and file operations.
+
+## Features
+
+- Command-line interface for building projects
+- Configurable via JSON and programmatic API
+- Utilities for cleaning build folders and managing configs
+- Rollup-based build process with plugin support
+
+## Quick Usage
+
+### CLI
+
+```sh
+node lib/Cli.js
+node lib/Cli.js --action build --name perso --config { "key": "value" }
+node lib/Cli.js --action build --name perso --config ABSOLUTE_PATH_TO_JSON_FILE
+```
+
+Options:
+- `--action, -a`  Build action (dist|build)
+- `--name, -n`    Name of the build
+- `--config, -c`  Path to the custom config file or JSON string
+- `--debug, -d`   Enable debug mode
+
+### Programmatic
+
+```js
+import jPackBuild from './lib/Build.js';
+
+await jPackBuild({
+	action: 'build',
+	name: 'perso',
+	config: 'PATH_TO_JSON_FILE',
+	debug: true
+});
+```
+
+### Create a jPacker
+
+Example from the "jizy-browser" extension.
+
+***First for the default dist build***
+
+#### ./config/config.json
+```json
+{
+    "desktopBreakpoint": "900px"
+}
+```
+
+#### ./config/jpack.js
+```js
+import fs from 'fs';
+import path from 'path';
+import { LogMe, jPackConfig } from 'jizy-packer';
+
+const jPackData = {
+    name: 'BrowserCompat',
+    alias: 'jizy-browser',
+
+    onCheckConfig: () => { 
+        // add some config validation
+        const desktopBreakpoint = jPackConfig.get('desktopBreakpoint');
+        if (!desktopBreakpoint) {
+            LogMe.error('Missing desktopBreakpoint in config');
+            process.exit(1);
+        }
+    },
+
+    // generate config.less
+    onGenerateBuildJs: (code) => {
+        LogMe.log('Generate config.less');
+        const desktopBreakpoint = jPackConfig.get('desktopBreakpoint') ?? '768px';
+        let lessContent = `@desktop-breakpoint: ${desktopBreakpoint};\n`;
+        lessContent += `@mobile-breakpoint: @desktop-breakpoint - 1px;`;
+        fs.writeFileSync(path.join(jPackConfig.get('targetPath'), 'config.less'), lessContent);
+        return code;
+    },
+
+    // parse wrapped js
+    onGenerateWrappedJs: (wrapped) => wrapped,
+
+    // after packing
+    onPacked: () => { }
+};
+
+export default jPackData;
+```
+
+#### ./config/jpack.template
+```js
+import BrowserCompat from '{{PREFIX}}lib/js/browsercompat.js';
+import '{{PREFIX}}lib/browsercompat.less';
+export default BrowserCompat;
+```
+
+#### ./config/jpack.wrapper.js
+```js
+/*! BrowserCompat v@VERSION | @DATE | [@BUNDLE] */
+(function (global) {
+    "use strict";
+
+    if (typeof global !== "object" || !global || !global.document) {
+        throw new Error("BrowserCompat requires a window and a document");
+    }
+
+    if (typeof global.BrowserCompat !== "undefined") {
+        throw new Error("BrowserCompat is already defined");
+    }
+
+    // @CODE 
+
+    global.BrowserCompat = BrowserCompat;
+
+})(typeof window !== "undefined" ? window : this);
+```

package/lib/Build.js

@@ -5,187 +5,151 @@ import { rollup } from 'rollup';
 import LogMe from "./LogMe.js";
 import jPackConfig from "./Config.js";
 import jPackRollup from "./Rollup.js";
-import { cleanBuildFolder } from './utils.js';
+import { emptyTargetPath, loadJson } from "./utils.js";
+
+/**
+ * @param {string}  action   the build action (dist|build) defaults to dist
+ * @param {string}  name     the name of the build ([a-z0-9\-\_]) 
+ * @param {string } config   the path to the custom config.json file
+ * @param {boolean} debug    for verbose logging
+ * 
+ * 1. build dist default export
+ *    no params
+ *    default package config
+ *    use ./config/jpack.js
+ *    use ./config/config.json
+ * 2. build custom config
+ *    name (default to custom)
+ *    default package config
+ *    use ./config/jpack.js
+ *    use ./config/config.json
+ *    custom package config
+ *    use [ABS_PATH_TO_CONFIG].json or json string
+ */
 
 export default async function jPackBuild({
-    target = null,
+    action = null,
     name = null,
-    zip = false,
+    config = null,
     debug = false
 } = {}) {
 
-    LogMe.log('---');
-
     if (debug) {
         process.env.DEBUG = true;
     }
 
-    LogMe.log('Build project...');
-
-    if (!target || target === 'dist') {
-        target = '';
-        name = '';
-        zip = false;
+    if (!action || action !== 'build') {
+        action = 'dist';
     }
 
-    if (zip && !name) {
-        name = 'zip';
+    if (config) {
+        action = 'build';
     }
 
-    if (target && !name) {
-        name = target;
-    }
-
-    if (!name) {
+    if (action === 'dist') {
         name = 'default';
+        config = null;
+    } else {
+        // Sanitize the build folder name
+        if (name) {
+            name = name.replace(/[^a-zA-Z0-9\-\_]/g, '');
+            name = name.toLowerCase();
+        }
+
+        if (!name) {
+            name = 'custom';
+        }
     }
 
-    LogMe.log('  Target: ' + target);
-    LogMe.log('  Name: ' + name);
-    LogMe.log('  Zip: ' + (zip ? 'enabled' : 'disabled'));
-    LogMe.log('  Debug: ' + (debug ? 'enabled' : 'disabled'));
+    LogMe.log('---');
+    LogMe.log('action: ' + action);
+    LogMe.log('name:   ' + name);
+    LogMe.log('config: ' + (config ? 'yes' : 'no'));
+    LogMe.log('debug:  ' + (debug ? 'enabled' : 'disabled'));
     LogMe.log('---');
 
-    jPackConfig.set('buildZip', zip);
     jPackConfig.set('buildName', name);
+    jPackConfig.set('action', action);
+    jPackConfig.set('debug', debug);
 
-    if (target) {
-        jPackConfig.set('buildTarget', jPackConfig.get('basePath') + '/build/' + target);
-        if (!fs.existsSync(jPackConfig.get('buildTarget'))) {
-            fs.mkdirSync(jPackConfig.get('buildTarget'), { recursive: true });
-        }
-    } else {
-        LogMe.log('Empty or create dist directory');
-        const targetPath = path.join(jPackConfig.get('basePath'), 'dist');
-        jPackConfig.set('buildTarget', targetPath);
-        cleanBuildFolder(targetPath);
-
-        const targetCfgPath = path.join(targetPath, 'config.json');
-        if (!fs.existsSync(targetCfgPath)) {
-            const defaultCfgPath = path.join(jPackConfig.get('basePath'), 'config', 'config.json');
-            if (fs.existsSync(defaultCfgPath)) {
-                LogMe.log('Copy default config.json file');
-                fs.copyFileSync(defaultCfgPath, targetCfgPath);
-            }
-        }
-    }
+    try {
+        LogMe.log('Load jPack config');
 
-    const defaultCfgPath = path.join(jPackConfig.get('basePath'), 'config', 'config.json');
-    const targetCfgPath = path.join(jPackConfig.get('buildTarget'), 'config.json');
-    if (!fs.existsSync(targetCfgPath)) {
-        if (fs.existsSync(defaultCfgPath)) {
-            LogMe.log('Copy default config.json file');
-            fs.copyFileSync(defaultCfgPath, targetCfgPath);
+        const jpack = path.join(jPackConfig.get('basePath'), 'config', 'jpack.js');
+        if (!fs.existsSync(jpack)) {
+            throw new Error('Default jPack config not found in ' + jpack);
         }
-    }
-
-    if (fs.existsSync(defaultCfgPath)) {
-        LogMe.log('Load default config file');
-        LogMe.log(defaultCfgPath);
-        jPackConfig.loadFromJson(defaultCfgPath);
-    }
 
-    const cfgPath = checkTargetDirectory(jPackConfig.get('buildTarget'));
-    if (fs.existsSync(cfgPath)) {
-        LogMe.log(`Load client config file`);
-        LogMe.log(cfgPath);
-        jPackConfig.loadFromJson(cfgPath);
-    }
+        require(jpack);
 
-    try {
         jPackConfig.setPackageVersion();
-        checkConfig();
-        await doBuild();
     } catch (error) {
-        LogMe.error(`Failed to load configuration file: ${cfgPath}`);
         LogMe.error(error.message);
         process.exit(1);
     }
-};
-
-async function doBuild() {
-    LogMe.log('---');
-    LogMe.dir(jPackConfig.all());
-    LogMe.log('---');
 
-    const inputOptions = {
-        input: jPackConfig.get('buildJsFilePath'),
-        plugins: jPackRollup(),
-    };
+    if (config) {
+        LogMe.log('Load the build config');
+        try {
+            if (config.substr(0, 1) === '{') {
+                LogMe.log('  JSON string');
+                jPackConfig.sets(JSON.parse(config));
+            } else {
+                LogMe.log('  JSON file');
+                jPackConfig.sets(loadJson(config));
+            }
+        } catch (error) {
+            LogMe.error('  ' + error.message);
+            process.exit(1);
+        }
+    }
 
-    const outputOptions = {
-        file: jPackConfig.get('assetsPath') + '/js/' + jPackConfig.get('alias') + '.min.js',
-        format: "iife",
-        name: jPackConfig.get('name'),
-        sourcemap: false,
-    };
+    jPackConfig.validate();
 
     try {
-        LogMe.log('Starting Rollup build...');
-        const bundle = await rollup(inputOptions);
-        await bundle.write(outputOptions);
-        LogMe.log('Rollup build completed successfully.');
+        LogMe.log('Empty the target directory');
+        LogMe.log('  TargetPath: ' + jPackConfig.get('targetPath'));
+        emptyTargetPath(jPackConfig.get('targetPath'));
     } catch (error) {
-        console.error('Error during Rollup build:', error);
+        LogMe.error('  ' + error.message);
         process.exit(1);
     }
-}
 
-function checkTargetDirectory(targetPath) {
-    LogMe.log('checkTargetDirectory()');
+    LogMe.log('Launch build ...');
 
-    if (!fs.existsSync(targetPath)) {
-        LogMe.error(`Does not exist: ${targetPath}`);
-        process.exit(1);
-    }
+    try {
+        LogMe.log('---');
+        LogMe.dir(jPackConfig.all());
+        LogMe.log('---');
+
+        const inputOptions = {
+            input: jPackConfig.get('buildJsFilePath'),
+            plugins: jPackRollup(),
+        };
+
+        const outputOptions = {
+            file: jPackConfig.get('targetRelativePath') + '/js/' + jPackConfig.get('alias') + '.min.js',
+            format: "iife",
+            name: jPackConfig.get('name'),
+            sourcemap: false,
+        };
+
+        try {
+            LogMe.log('Starting Rollup build...');
+            const bundle = await rollup(inputOptions);
+            await bundle.write(outputOptions);
+            LogMe.log('Rollup build completed successfully.');
+        } catch (error) {
+            console.error('Error during Rollup build:', error);
+            process.exit(1);
+        }
 
-    if (!fs.lstatSync(targetPath).isDirectory()) {
-        LogMe.error(`Is not a directory: ${targetPath}`);
+        LogMe.log('---');
+        LogMe.log('Build completed successfully');
+        LogMe.log('---');
         process.exit(1);
-    }
-
-    const cfgPath = path.join(targetPath, 'config.json');
-
-    if (!fs.existsSync(cfgPath)) {
-        LogMe.warn('  config.json not found in target path');
-        return null;
-    }
-
-    const files = fs.readdirSync(targetPath)
-        .filter(file => file !== 'config.json');
-
-    if (files.length > 0) {
-        LogMe.error('Build target can only contain config.json');
+    } catch (error) {
+        LogMe.error(error.message);
         process.exit(1);
     }
-
-    return cfgPath;
-}
-
-function checkConfig() {
-    const basePath = jPackConfig.get('basePath');
-
-    const buildName = jPackConfig.get('buildName')
-        .replace(/[^a-zA-Z0-9]/g, ''); // Sanitize the build folder name
-
-    jPackConfig.set('buildName', buildName);
-
-    if (buildName === 'default') {
-        jPackConfig.set('assetsPath', 'dist');
-        jPackConfig.set('importPrefix', '../');
-    }
-    else {
-        jPackConfig.set('assetsPath', 'build/' + buildName);
-        jPackConfig.set('importPrefix', '../../');
-    }
-
-    jPackConfig.set('assetsFullpath', path.join(basePath, jPackConfig.get('assetsPath')));
-    jPackConfig.set('buildJsFilePath', path.join(basePath, jPackConfig.get('assetsPath'), 'build.js'));
-    jPackConfig.set('buildTemplatePath', path.join(basePath, 'config', 'jpack.template'));
-    jPackConfig.set('wrapperPath', path.join(basePath, 'config', 'jpack.wrapper.js'));
-
-    const onCheckConfig = jPackConfig.get('onCheckConfig');
-    if (typeof onCheckConfig === 'function') {
-        onCheckConfig();
-    }
-}
+};

package/lib/Cli.js

@@ -3,17 +3,16 @@ import { hideBin } from 'yargs/helpers';
 import jPackBuild from "./Build.js";
 import jPackConfig from "./Config.js";
 
-const jPackCli = function (cfg) {
+const jPackCli = function () {
     jPackConfig.set('basePath', process.cwd());
-    jPackConfig.sets(cfg);
 
     const command = yargs(hideBin(process.argv))
         .usage('Usage: $0 <command> [options]')
-        .option('target', {
-            alias: 't',
+        .option('action', {
+            alias: 'a',
             type: 'string',
-            description: 'Target path',
-            default: '',
+            description: 'Set the build action (dist or build)',
+            default: 'dist',
         })
         .option('name', {
             alias: 'n',
@@ -21,11 +20,11 @@ const jPackCli = function (cfg) {
             description: 'Set the build name',
             default: '',
         })
-        .option('zip', {
-            alias: 'z',
-            type: 'boolean',
-            description: 'Create a zip file',
-            default: false,
+        .option('config', {
+            alias: 'c',
+            type: 'string',
+            description: 'Custom config absolute path or json string',
+            default: '',
         })
         .option('debug', {
             alias: 'd',

package/lib/Config.js

@@ -4,6 +4,10 @@ import path from 'path';
 const config = {};
 
 const jPackConfig = {
+    /**
+     * Returns a shallow copy of the current config object
+     * replacing functions with 'fn'.
+     */
     all: function () {
         const result = {};
         for (const key in config) {
@@ -17,54 +21,90 @@ const jPackConfig = {
         return result;
     },
 
-    loadFromJson: function (cfgPath) {
-        if (!fs.existsSync(cfgPath)) {
-            throw new Error(`Configuration file not found: ${cfgPath}`);
-        }
-
-        const data = fs.readFileSync(cfgPath, 'utf8');
-        const json = JSON.parse(data);
-        this.sets(json);
-    },
-
+    /**
+     * Loads the version from package.json and sets it in the config under 'version'.
+     */
     setPackageVersion: function () {
         const pkgPath = path.join(jPackConfig.get('basePath'), 'package.json');
+
         if (fs.existsSync(pkgPath)) {
             const data = fs.readFileSync(pkgPath, 'utf8');
             const json = JSON.parse(data);
+
             if (json.version) {
                 this.set('version', json.version);
+                return;
             }
         }
+
+        this.set('version', '0.0.1');
     },
 
-    check: function () {
+    /**
+     * Validates and prepares the config object, setting paths and defaults as needed.
+     * Throws if required fields are missing.
+     */
+    validate: function () {
         if (!config.basePath) {
             throw new Error('Invalid configuration: basePath is required.');
         }
 
-        if (!config.name) {
-            throw new Error('Invalid configuration: name is required.');
+        if (!config.buildName) {
+            throw new Error('Invalid configuration: buildName is required.');
+        }
+
+        if (config.action === 'dist') {
+            config.importPrefix = '../';
+            config.targetRelativePath = 'dist';
+            config.targetPath = path.join(config.basePath, 'dist');
+        }
+        else {
+            config.importPrefix = '../../';
+            config.targetPath = path.join(config.basePath, 'build', config.buildName);
+            config.targetRelativePath = 'build/' + config.buildName;
+        }
+
+        config.buildJsFilePath = path.join(config.targetPath, 'build.js');
+        config.buildTemplatePath = path.join(config.basePath, 'config', 'jpack.template');
+        config.wrapperPath = path.join(config.basePath, 'config', 'jpack.wrapper.js');
+
+        if (typeof config.onCheckConfig === 'function') {
+            config.onCheckConfig();
         }
 
         if (!config.alias) {
             config.alias = config.name.toLowerCase();
             config.alias = config.alias.replace(/\s+/g, '-');
         }
-
-        if (!config.cfg) {
-            config.cfg = config.alias;
-        }
     },
 
+    /**
+     * Merges a new config object into the current config.
+     * @param {Object} newConfig - The config object to merge.
+     */
     sets: (newConfig) => {
-        Object.assign(config, newConfig);
+        if (typeof newConfig !== 'object' || newConfig === null) {
+            throw new Error('Invalid configuration: newConfig must be an object.');
+        }
+        newConfig.array.forEach(element => {
+            this.set(element, newConfig[element]);
+        });
     },
 
+    /**
+     * Gets a config value by key, or returns the default if not set.
+     * @param {string} key - The config key.
+     * @param {*} def - The default value if key is not set.
+     */
     get(key, def) {
         return config[key] || def;
     },
 
+    /**
+     * Sets a config value by key.
+     * @param {string} key - The config key.
+     * @param {*} value - The value to set.
+     */
     set(key, value) {
         config[key] = value;
     }

package/lib/Rollup.js

@@ -6,22 +6,18 @@ import json from "@rollup/plugin-json";
 import resolve from "@rollup/plugin-node-resolve";
 import commonjs from "@rollup/plugin-commonjs";
 import terser from '@rollup/plugin-terser';
-import { execSync } from 'child_process';
 
 import jPackConfig from "./Config.js";
 import LogMe from "./LogMe.js";
-import { cleanBuildFolder } from "./utils.js";
+import { emptyTargetPath } from './utils.js';
 
 export default async function jPackRollup(config) {
-    const assetsPath = jPackConfig.get('assetsPath');
-
     return [
         {
             name: 'beforeBuild',
             buildStart() {
-                // target folder exists so empty
-                // should not happen since it's required to have an empty target folder
-                cleanBuildFolder(assetsPath);
+                LogMe.log('Prepare build folder');
+                emptyTargetPath(jPackConfig.get('targetPath'));
             },
         },
 
@@ -44,7 +40,7 @@ export default async function jPackRollup(config) {
             limit: 0,
             emitFiles: true,
             fileName: '[name][extname]',
-            destDir: assetsPath + '/fonts/',
+            destDir: jPackConfig.get('targetRelativePath') + '/fonts/',
         }),
 
         url({
@@ -52,7 +48,7 @@ export default async function jPackRollup(config) {
             limit: 0,
             emitFiles: true,
             fileName: '[name][extname]',
-            destDir: assetsPath + '/images/',
+            destDir: jPackConfig.get('targetRelativePath') + '/images/',
         }),
 
         json(), // Handle JSON imports
@@ -77,6 +73,9 @@ export default async function jPackRollup(config) {
     ];
 };
 
+function cleanBuildFolder() {
+}
+
 function generateBuildJs() {
     LogMe.log('Generate the build.js file ...');
 
@@ -154,13 +153,13 @@ function onPacked() {
 
 function moveCssFiles() {
     LogMe.log('Moving CSS files from js/ to css/ ...');
-    const assetsPath = jPackConfig.get('assetsPath');
+    const targetPath = jPackConfig.get('targetPath');
 
-    fs.readdirSync(assetsPath + '/js')
+    fs.readdirSync(targetRelativePath + '/js')
         .filter(file => file.endsWith('.css'))
         .forEach(file => {
-            const oldPath = path.join(assetsPath + '/js', file);
-            const newPath = path.join(assetsPath + '/css', file);
+            const oldPath = path.join(targetRelativePath + '/js', file);
+            const newPath = path.join(targetRelativePath + '/css', file);
             fs.mkdirSync(path.dirname(newPath), { recursive: true });
             fs.renameSync(oldPath, newPath);
             LogMe.log('- ' + file);
@@ -176,83 +175,13 @@ function cleanupBuild() {
         fs.unlinkSync(jPackConfig.get('buildJsFilePath'));
     }
 
-    let emptyBuildFolder = false;
-    const ignoreRemove = [];
-
-    if (jPackConfig.get('buildZip')) {
-        LogMe.log('Creating zip file ...');
-        const zipFilePath = path.join(jPackConfig.get('assetsFullpath'), jPackConfig.get('buildName') + '.zip');
-
-        execSync(`cd ${jPackConfig.get('assetsFullpath')} && zip -r ${zipFilePath} .`, { stdio: 'inherit' });
-        LogMe.log('-> ' + zipFilePath);
-
-        if (jPackConfig.get('buildTarget')) {
-            LogMe.log('Transfer zip file ...');
-            const zipTargetPath = path.join(jPackConfig.get('buildTarget'), jPackConfig.get('buildName') + '.zip');
-            fs.copyFileSync(zipFilePath, zipTargetPath);
-            LogMe.log('-> ' + zipTargetPath);
-        }
-
-        emptyBuildFolder = true;
-        ignoreRemove.push(zipFilePath);
-    }
-    else if (jPackConfig.get('buildTarget') && jPackConfig.get('assetsPath') !== 'dist') {
-        LogMe.log('Copy generated build folder ...');
-
-        fs.mkdirSync(jPackConfig.get('buildTarget'), { recursive: true });
-
-        // Iterate over the files and directories in jPackConfig.get('assetsPath')
-        fs.readdirSync(jPackConfig.get('assetsPath')).forEach(file => {
-            const sourcePath = path.join(jPackConfig.get('assetsPath'), file);
-            const destinationPath = path.join(jPackConfig.get('buildTarget'), file);
-
-            if (fs.lstatSync(sourcePath).isDirectory()) {
-                // Recursively copy directories
-                fs.mkdirSync(destinationPath, { recursive: true });
-                fs.readdirSync(sourcePath).forEach(subFile => {
-                    const subSourcePath = path.join(sourcePath, subFile);
-                    const subDestinationPath = path.join(destinationPath, subFile);
-                    fs.copyFileSync(subSourcePath, subDestinationPath);
-                    LogMe.log('- Copied file: ' + subDestinationPath);
-                });
-            } else {
-                // Copy files
-                fs.copyFileSync(sourcePath, destinationPath);
-                LogMe.log('- Copied file: ' + destinationPath);
+    fs.readdirSync(jPackConfig.get('targetPath')).forEach(file => {
+        const filePath = path.join(jPackConfig.get('targetPath'), file);
+        if (fs.lstatSync(filePath).isDirectory()) {
+            if (fs.readdirSync(filePath).length === 0) {
+                fs.rmdirSync(filePath);
+                LogMe.log('Removed empty folder: ' + filePath);
             }
-        });
-
-        emptyBuildFolder = true;
-    }
-
-    if (emptyBuildFolder) {
-        LogMe.log('Cleaning up build folder ...');
-
-        fs.readdirSync(jPackConfig.get('assetsPath')).forEach(file => {
-            const filePath = path.join(jPackConfig.get('assetsPath'), file);
-            if (fs.lstatSync(filePath).isDirectory()) {
-                fs.rmSync(filePath, { recursive: true, force: true });
-                LogMe.log('Removed folder: ' + filePath);
-            }
-            else {
-                if (filePath.endsWith('.zip')) {
-                    return;
-                }
-
-                fs.unlinkSync(filePath);
-                LogMe.log('Removed file: ' + filePath);
-            }
-        });
-    }
-    else {
-        fs.readdirSync(jPackConfig.get('assetsPath')).forEach(file => {
-            const filePath = path.join(jPackConfig.get('assetsPath'), file);
-            if (fs.lstatSync(filePath).isDirectory()) {
-                if (fs.readdirSync(filePath).length === 0) {
-                    fs.rmdirSync(filePath);
-                    LogMe.log('Removed empty folder: ' + filePath);
-                }
-            }
-        });
-    }
+        }
+    });
 }

package/lib/index.js

@@ -3,14 +3,11 @@ import jPackCli from './Cli.js';
 import jPackConfig from './Config.js';
 import LogMe from './LogMe.js';
 import jPackRollup from './Rollup.js';
-import { removeEmptyDirs, cleanBuildFolder } from './utils.js';
 
 export {
     jPackBuild,
     jPackCli,
     jPackConfig,
     LogMe,
-    jPackRollup,
-    removeEmptyDirs,
-    cleanBuildFolder
+    jPackRollup
 }

package/lib/utils.js

@@ -1,43 +1,87 @@
 import fs from 'fs';
 import path from 'path';
+
 import LogMe from './LogMe.js';
 
-export function removeEmptyDirs(dir) {
-    if (!fs.existsSync(dir)) return;
+export function emptyTargetPath(targetPath) {
+    if (!fs.existsSync(targetPath)) {
+        fs.mkdirSync(targetPath, { recursive: true });
+    }
+
+    if (!fs.lstatSync(targetPath).isDirectory()) {
+        throw new Error(`Target path is not a directory`);
+    }
+
+    let files = fs.readdirSync(targetPath);
 
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const fullPath = path.join(dir, file);
-        if (fs.lstatSync(fullPath).isDirectory()) {
-            removeEmptyDirs(fullPath);
+    if (files.length > 0) {
+        for (const file of files) {
+            const fullPath = path.join(targetPath, file);
+            if (fs.lstatSync(fullPath).isDirectory()) {
+                try {
+                    emptyTargetPath(fullPath);
+                } catch (error) {
+                    LogMe.error('Failed to empty directory: ' + fullPath);
+                    LogMe.error(error.message);
+                }
+            }
+            else {
+                fs.unlinkSync(fullPath);
+                LogMe.log('  [RM] ' + fullPath);
+            }
         }
+
+        files = fs.readdirSync(targetPath);
     }
 
-    // After removing subdirs, check if current dir is empty
-    if (fs.readdirSync(dir).length === 0) {
-        fs.rmdirSync(dir);
+    if (files.length === 0) {
+        LogMe.log('  [RM] ' + targetPath);
+        fs.rmdirSync(targetPath);
     }
 };
 
-export function cleanBuildFolder(buildPath) {
-    LogMe.log('cleanBuildFolder()');
-
-    if (fs.existsSync(buildPath)) {
-        LogMe.log('  Cleanup');
-        fs.readdirSync(buildPath).forEach(file => {
-            if (file !== 'config.json') {
-                const filePath = path.join(buildPath, file);
-                if (fs.lstatSync(filePath).isDirectory()) {
-                    fs.rmSync(filePath, { recursive: true, force: true });
-                    LogMe.log('  - [RM] ' + filePath);
-                } else {
-                    fs.unlinkSync(filePath);
-                    LogMe.log('  - [RM] ' + filePath);
-                }
-            }
-        });
-    } else {
-        fs.mkdirSync(buildPath, { recursive: true });
-        LogMe.log('  Created target directory');
+export function loadJson(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            throw new Error('File not found');
+        }
+
+        const data = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(data);
+        return json;
+
+    } catch (error) {
+        throw new Error(`Failed to load JSON file: ${filePath}\n${error.message}`);
+    }
+};
+
+export function loadJsonConfigs(...configs) {
+    const loadedConfigs = [];
+    for (const configPath of configs) {
+        if (!fs.existsSync(configPath)) {
+            continue;
+        }
+        loadedConfigs.push(loadJson(configPath));
+    }
+    let mergedConfig = {};
+    for (const conf of loadedConfigs) {
+        mergedConfig = deepMerge(mergedConfig, conf);
+    }
+    return mergedConfig;
+};
+
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+function deepMerge(target, source) {
+    for (const key in source) {
+        if (isObject(source[key])) {
+            if (!target[key]) Object.assign(target, { [key]: {} });
+            deepMerge(target[key], source[key]);
+        } else {
+            target[key] = source[key];
+        }
     }
-};
+    return target;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jizy-packer",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "type": "module",
   "files": [
     "lib/*.js"