v0.0.11: Added unit-tests, solved the key={...} problem, updated the build/watch configuration of CSX to be able to build minified and non-minified bundle outputs, as well as a CJS version of lib/ (for consuming in Node-environment, like Jest). The previous tests were renamed to examples, and should still need to be updated.

packages/csx/cfg/config.js

@@ -0,0 +1,170 @@
+// @cerxes
+import { host, Host } from "@cerxes/host";
+
+// Rollup and plugins
+import babel from 'rollup-plugin-babel';
+import resolve from 'rollup-plugin-node-resolve';
+import { terser } from 'rollup-plugin-terser';
+
+// Proc args (this is weird to be here, but it is the same for build/watch, and should be kept in sync as much as possible
+import process from "process";
+import * as rollup from "rollup";
+import { logBundle } from "./log-bundle";
+let args = process.argv.slice(2);
+const runArgSeperator = args.indexOf('--');
+export let buildTargets = ['lib-es', 'lib-cjs', 'dist-es', 'dist-es-min', 'dist-cjs', 'dist-cjs-min'];
+if (runArgSeperator >= 0) {
+    buildTargets = args.slice(runArgSeperator + 1);
+    args = args.slice(0, runArgSeperator);
+}
+
+export class CsxConfig {
+    constructor({
+        src,
+        dist,
+        root,
+        opts
+    } = {}) {
+        const { watch } = opts || {};
+
+        this.root = root ? host.from(root) : host.from('.');// (This host.from('.') would not've been necessary if @cerxes/host did not have a bug on this one)
+        this.src = this.root.from(src || 'src');
+        this.dist = this.root.from(dist || 'dist');
+        this.lib = this.root.from(dist || 'lib');
+    }
+
+    /** @type {Host} */
+    src;
+    /**
+     *  Directory to use for dist output (single bundle)
+     *  @type {Host} */
+    dist;
+    /**
+     *  Directory to use for library output (transpiled, file by file)
+     *  @type {Host} */
+    lib;
+
+    /** @type {string} */
+    sourceGlob = "**/*.@(*.js|js)";
+
+    /**
+     * Get rollup-config to compile a source file
+     * @param {string} file
+     * @param {string} out
+     * @param {object} [opts]
+     * @param {boolean} [opts.es] - Export in es6 format (or cjs when false)
+     * @param {boolean} [opts.single] - Compile single file (e.g. don't follow imports)
+     * @param {boolean} [opts.sourcemap] - Include sourcemaps
+     * @param {boolean} [opts.minified] - Minify the output (e.g. Terser-plugin)
+     * @returns {{output: {file: string, sourcemap: boolean, plugins: Array<Object>, format: string}, input: string, plugins: ...*[]}}
+     */
+    srcCfg = (file, out = undefined, opts) => {
+        let inputFile = this.src.resolve(file);
+        let outputFile = this.dist.resolve(out || file);
+        return ({
+            // Compile the actual app
+            input: inputFile,
+            output: {
+                file: outputFile,
+                format: opts?.es? 'es' : 'cjs', // NodeJS
+                sourcemap: opts?.sourcemap ?? true,
+            },
+            external: (id, parentId, isResolved) => {
+                if (!id || id[0] === '\0') return false;// Special cases
+                else {
+                    let split = (id || "").split('/');
+                    let first = id[0] === '@' ? split.slice(0, 2).join('/') : split[0];
+                    let absId = first === '..' || first === '.' ? this.src.resolve(parentId, id) : id;
+                    if (absId) {
+                        if(absId.indexOf(this.src.workingDirectory) >= 0 && opts?.single) return true; // Own source-file => external when single mode enabled
+                    }
+                    // Any other unresolved identifier(which should be resolved further)
+                    return false; // The light, inline them
+                }
+            },
+            treeshake: !opts?.single,
+            plugins: [
+                // babel
+                babel({
+                    babelrc: true,
+                }),
+                // NodeJS-style resolving (Its a shame this is not a Rollup-default, we need this for index.js files to work!)
+                resolve({
+                    extensions: ['.mjs', '.js', '.jsx', '.json'],
+                    preferBuiltins: true, mainFields: ['browser']
+                }),
+                opts?.minified ? terser() : null
+            ].filter(t=>t)
+        })
+    };
+    
+    /**
+     * @param {string} sources
+     * @returns {TargetConfig[]}
+     */
+    configureTargets = (sources)=>{
+        return buildTargets.map(target=>{
+            let {lib,dist,root} = this;
+            let [type, format, minified] = target.split("-");
+            let inputs = type==='lib'? sources : ['index.js'];
+            let srcOpts = {
+                es: format==='es',
+                single: type==='lib',
+                sourcemap: true,// Just always there for now
+                minified: !!minified
+            };
+            let outDir = type==='lib'? lib : dist;
+    
+            return new TargetConfig({
+                target,
+                sources: inputs.map(input=>{
+                    let outName = input.replace(
+                        /\.js$/,
+                        `.${[
+                            type==='dist'? srcOpts.es?'es':'cjs' : null,
+                            srcOpts.minified?'min':null,
+                            'js'
+                        ].filter(x=>x).join('.')}`);
+                    if(type==='lib') outName = [srcOpts.es?'es':'cjs',outName].join('/');
+                    
+                    return new SourceConfig({
+                        source: input,
+                        config: this.srcCfg(input, outDir.resolve(outName), srcOpts)
+                    });
+                })
+            });
+        });
+    }
+}
+
+/**
+ * Configure a source-file for build (single target)
+ */
+export class SourceConfig{
+    /** @param {SourceConfig} c */
+    constructor(c){
+        this.source = c.source;
+        this.config = c.config;
+    }
+    /** @type {string} */
+    source;
+    
+    /** @type {RollupOptions} */
+    config;
+}
+
+/**
+ * Represent the configuration for a specific build target (e.g. lib-es, dist-cjs, ...)
+ */
+export class TargetConfig{
+    /** @param {TargetConfig} c */
+    constructor(c){
+        this.target = c.target;
+        this.sources = c.sources;
+    }
+    /** @type {string} */
+    target;
+    
+    /** @type {SourceConfig[]} */
+    sources;
+}