jizy-packer 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Joffrey Demetz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# jizy-packer
+Build a CLI app to generate optimized builds.

package/bin/jpack.js

@@ -0,0 +1,38 @@
+import yargs from "yargs/yargs";
+import { hideBin } from 'yargs/helpers';
+import jPackBuild from "../Build.js";
+import jPackConfig from "../Config.js";
+
+jPackConfig.set('basePath', process.cwd());
+
+const command = yargs(hideBin(process.argv))
+    .usage('Usage: $0 <command> [options]')
+    .option('target', {
+        alias: 't',
+        type: 'string',
+        description: 'Target path',
+        default: '',
+    })
+    .option('name', {
+        alias: 'n',
+        type: 'string',
+        description: 'Set the build name',
+        default: '',
+    })
+    .option('zip', {
+        alias: 'z',
+        type: 'boolean',
+        description: 'Create a zip file',
+        default: false,
+    })
+    .option('debug', {
+        alias: 'd',
+        type: 'boolean',
+        description: 'Enable debug mode',
+        default: false,
+    })
+    .help()
+    .alias('help', 'h');
+
+const argv = command.parse();
+jPackBuild(argv);

package/lib/Build.js

@@ -0,0 +1,188 @@
+import fs from 'fs';
+import path from 'path';
+import { rollup } from 'rollup';
+
+import LogMe from "./LogMe.js";
+import jPackConfig from "./Config.js";
+import jPackRollup from "./Rollup.js";
+import { cleanBuildFolder } from '../utils.js';
+
+export default async function jPackBuild({
+    target = null,
+    name = null,
+    zip = false,
+    debug = false
+} = {}) {
+
+    LogMe.log('---');
+
+    if (debug) {
+        process.env.DEBUG = true;
+    }
+
+    LogMe.log('Build project...');
+
+    if (!target || target === 'dist') {
+        target = '';
+        name = '';
+        zip = false;
+    }
+
+    if (zip && !name) {
+        name = 'zip';
+    }
+
+    if (target && !name) {
+        name = 'export';
+    }
+
+    if (!name) {
+        name = 'default';
+    }
+
+    LogMe.log('  Target: ' + target);
+    LogMe.log('  Name: ' + name);
+    LogMe.log('  Zip: ' + (zip ? 'enabled' : 'disabled'));
+    LogMe.log('  Debug: ' + (debug ? 'enabled' : 'disabled'));
+    LogMe.log('---');
+
+    jPackConfig.set('buildZip', zip);
+    jPackConfig.set('buildName', name);
+
+    if (target) {
+        jPackConfig.set('buildTarget', jPackConfig.get('basePath') + '/build/' + target);
+    } 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);
+            }
+        }
+    }
+
+    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);
+        }
+    }
+
+    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);
+    }
+
+    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(),
+    };
+
+    const outputOptions = {
+        file: jPackConfig.get('assetsPath') + '/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);
+    }
+}
+
+function checkTargetDirectory(targetPath) {
+    LogMe.log('checkTargetDirectory()');
+
+    if (!fs.existsSync(targetPath)) {
+        LogMe.error(`Does not exist: ${targetPath}`);
+        process.exit(1);
+    }
+
+    if (!fs.lstatSync(targetPath).isDirectory()) {
+        LogMe.error(`Is not a directory: ${targetPath}`);
+        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');
+        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/Config.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+
+const config = {};
+
+const jPackConfig = {
+    all: function () {
+        const result = {};
+        for (const key in config) {
+            if (typeof config[key] === 'function') {
+                result[key] = 'fn';
+            }
+            else {
+                result[key] = config[key];
+            }
+        }
+        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);
+    },
+
+    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);
+            }
+        }
+    },
+
+    check: 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.alias) {
+            config.alias = config.name.toLowerCase();
+            config.alias = config.alias.replace(/\s+/g, '-');
+        }
+
+        if (!config.cfg) {
+            config.cfg = config.alias;
+        }
+    },
+
+    sets: (newConfig) => {
+        Object.assign(config, newConfig);
+    },
+
+    get(key, def) {
+        return config[key] || def;
+    },
+
+    set(key, value) {
+        config[key] = value;
+    }
+};
+
+export default jPackConfig;

package/lib/LogMe.js

@@ -0,0 +1,25 @@
+const LogMe = {
+    doLog: (method, ...message) => {
+        if (!process.env.DEBUG) {
+            return;
+        }
+        console[method](...message);
+    },
+    log: (...message) => {
+        LogMe.doLog('log', ...message);
+    },
+    warn: (...message) => {
+        LogMe.doLog('warn', ...message);
+    },
+    error: (...message) => {
+        LogMe.doLog('error', ...message);
+    },
+    debug: (...message) => {
+        LogMe.doLog('debug', ...message);
+    },
+    dir: (...message) => {
+        LogMe.doLog('dir', ...message);
+    },
+};
+
+export default LogMe;

package/lib/Rollup.js

@@ -0,0 +1,258 @@
+import fs from 'fs';
+import path from 'path';
+import postcss from "rollup-plugin-postcss";
+import url from "@rollup/plugin-url";
+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";
+
+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);
+            },
+        },
+
+        {
+            name: 'preprocess',
+            buildStart() {
+                generateBuildJs();
+            },
+        },
+
+        postcss({
+            extract: jPackConfig.get('alias') + '.min.css', // Save CSS to dist/css/
+            minimize: true, // Minify CSS
+            sourceMap: false, // Disable source map for CSS
+            extensions: ['.less'], // Process LESS files
+        }),
+
+        url({
+            include: ['**/*.woff', '**/*.woff2'],
+            limit: 0,
+            emitFiles: true,
+            fileName: '[name][extname]',
+            destDir: assetsPath + '/fonts/',
+        }),
+
+        url({
+            include: ['**/*.png'],
+            limit: 0,
+            emitFiles: true,
+            fileName: '[name][extname]',
+            destDir: assetsPath + '/images/',
+        }),
+
+        json(), // Handle JSON imports
+        resolve(), // Resolve Node.js modules
+        commonjs(), // Convert CommonJS modules to ES6
+
+        {
+            name: 'wrap',
+            renderChunk(code) {
+                return generateWrappedJs(code);
+            },
+        },
+
+        terser(),
+
+        {
+            name: 'jpacked',
+            writeBundle() {
+                onPacked();
+            },
+        }
+    ];
+};
+
+function generateBuildJs() {
+    LogMe.log('Generate the build.js file ...');
+
+    // Read the build template
+    let code = fs.readFileSync(jPackConfig.get('buildTemplatePath'), 'utf8');
+
+    // append config callback
+    const onGenerateBuildJs = jPackConfig.get('onGenerateBuildJs');
+    if (typeof onGenerateBuildJs === 'function') {
+        console.log('Calling onGenerateBuildJs callback');
+        code = onGenerateBuildJs(code);
+    }
+
+    code = code.replace(/{{PREFIX}}/g, jPackConfig.get('importPrefix'));
+
+    fs.writeFileSync(jPackConfig.get('buildJsFilePath'), code, 'utf8');
+
+    if (fs.existsSync(jPackConfig.get('buildJsFilePath'))) {
+        LogMe.log('Generated build successfully in "' + jPackConfig.get('buildJsFilePath') + '"');
+    } else {
+        console.error('Error: Generated build file not found: ' + jPackConfig.get('buildJsFilePath'));
+        process.exit(1);
+    }
+}
+
+function generateWrappedJs(code) {
+    LogMe.log('Generate the wrapper.js file ...');
+
+    const date = new Date();
+    const wrapper = fs.readFileSync(jPackConfig.get('wrapperPath'), 'utf8');
+
+    const marker = '// @CODE';
+    const codePosition = wrapper.indexOf(marker);
+    if (codePosition === -1) {
+        console.error('Error: "// @CODE" not found in wrapper file');
+        process.exit(1);
+    }
+
+    // Insert code after the marker (keeping the marker and its line)
+    const markerEnd = codePosition + marker.length;
+    // Find the end of the line (so code is inserted after the marker's line)
+    const lineEnd = wrapper.indexOf('\n', markerEnd);
+    let insertPos = lineEnd !== -1 ? lineEnd + 1 : markerEnd;
+
+    let wrapped = wrapper.slice(0, insertPos) + code + '\n' + wrapper.slice(insertPos);
+
+    wrapped = wrapped.replace(marker, '');
+    wrapped = wrapped.replace(/@VERSION/g, jPackConfig.get('version'));
+    wrapped = wrapped.replace(/@BUNDLE/g, jPackConfig.get('buildName'));
+    wrapped = wrapped.replace(/@DATE/g, date.toISOString().replace(/:\d+\.\d+Z$/, "Z"));
+
+    const onGenerateWrappedJs = jPackConfig.get('onGenerateWrappedJs');
+    if (typeof onGenerateWrappedJs === 'function') {
+        wrapped = onGenerateWrappedJs(wrapped);
+    }
+
+    return wrapped;
+}
+
+function onPacked() {
+    LogMe.log('Build completed successfully.');
+
+    moveCssFiles();
+
+    const onPacked = jPackConfig.get('onPacked');
+    if (typeof onPacked === 'function') {
+        onPacked();
+    }
+
+    // Cleanup the build folder
+    cleanupBuild();
+
+    LogMe.log('Build process completed.');
+}
+
+function moveCssFiles() {
+    LogMe.log('Moving CSS files from js/ to css/ ...');
+    const assetsPath = jPackConfig.get('assetsPath');
+
+    fs.readdirSync(assetsPath + '/js')
+        .filter(file => file.endsWith('.css'))
+        .forEach(file => {
+            const oldPath = path.join(assetsPath + '/js', file);
+            const newPath = path.join(assetsPath + '/css', file);
+            fs.mkdirSync(path.dirname(newPath), { recursive: true });
+            fs.renameSync(oldPath, newPath);
+            LogMe.log('- ' + file);
+        });
+}
+
+function cleanupBuild() {
+    LogMe.log('Cleaning up generated build ...');
+
+    // Remove the generated build.js file
+    if (fs.existsSync(jPackConfig.get('buildJsFilePath'))) {
+        LogMe.log('Removed generated build.js file');
+        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);
+            }
+        });
+
+        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/utils.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+import LogMe from './LogMe.js';
+
+export function removeEmptyDirs(dir) {
+    if (!fs.existsSync(dir)) return;
+
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        if (fs.lstatSync(fullPath).isDirectory()) {
+            removeEmptyDirs(fullPath);
+        }
+    }
+
+    // After removing subdirs, check if current dir is empty
+    if (fs.readdirSync(dir).length === 0) {
+        fs.rmdirSync(dir);
+    }
+};
+
+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');
+    }
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "jizy-packer",
+  "version": "2.0.0",
+  "type": "module",
+  "files": [
+    "lib/*.js"
+  ],
+  "bin": {
+    "jizy-pack": "./bin/jpack.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "build:export": "node ./bin/jpack.js -t perso",
+    "build:export-debug": "node ./bin/jpack.js -t perso --debug",
+    "build:dist": "node ./bin/jpack.js -t dist -n default",
+    "build:dist-debug": "node ./bin/jpack.js -t dist -n default --debug"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joffreydemetz/jizy-packer.git"
+  },
+  "keywords": [
+    "jizy",
+    "packer",
+    "utilities"
+  ],
+  "author": "Joffrey Demetz <joffrey.demetz@gmail.com> (https://joffreydemetz.com/)",
+  "license": "MIT",
+  "description": "CLI app to generate optimized builds.",
+  "devDependencies": {
+    "@babel/core": "^7.26.10",
+    "@babel/preset-env": "^7.26.9",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-url": "^8.0.2",
+    "autoprefixer": "^10.4.21",
+    "babel-jest": "^29.7.0",
+    "clean-css": "^5.3.3",
+    "cross-env": "^7.0.3",
+    "cssnano": "^7.0.6",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jsdom": "^26.1.0",
+    "less": "^4.3.0",
+    "less-plugin-clean-css": "^1.6.0",
+    "postcss": "^8.5.3",
+    "rollup": "^4.40.1",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-delete": "^3.0.1",
+    "rollup-plugin-postcss": "^4.0.2",
+    "yargs": "^17.7.2"
+  },
+  "jest": {
+    "testEnvironment": "jsdom",
+    "transform": {
+      "^.+\\.js$": "babel-jest"
+    }
+  }
+}