@polylith/builder 0.0.22 → 0.0.24

package/App.js

@@ -1,33 +1,33 @@
-import path from 'path';
-import fs from 'fs-extra';
+import path from 'node:path';
+import {readFile, writeFile, stat} from 'node:fs/promises';
 
 import * as rollup from 'rollup';
 import { babel } from '@rollup/plugin-babel';
 import * as resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
-import html from "rollup-plugin-html";
+import html from 'rollup-plugin-html';
 
 import loader from './plugin-loader.js';
 import mainHTML from './plugin-main-html.js';
 import features from './plugin-features.js';
 import styles from "rollup-plugin-styles";
 
+import ConfigFeature from './ConfigFeature';
+
 /**
- * call this method to get the path from the a filename, and force the file path 
- * to use posix notation and remove all drive information. This will likely
- * be used by parent App implementations in their constructors
- * 
- * 
- * @param {String} src the filename wqe
- * @returns {String} the new path
+ * call this function to check if the given file exists
+ *
+ * @param {String} path the name of the file
+ * @returns {Promise<Boolean>} true if the file exists
  */
-function fixPath(src) {
-	src = src.replace('file:', '');
-	src = src.replace('///', '');
-	src = src.replace(/.:/, '');
-	src = src.replace(/\\/g, '/');
 
-	return src;
+async function fileExists(path) {
+    try {
+        await stat(path)
+        return true;
+    } catch (e) {
+        return false;
+    }
 }
 
 /**
@@ -36,18 +36,18 @@ function fixPath(src) {
 export class App {
 	/**
 	 * Construct the app object.
-	 * 
+	 *
 	 * @param {String} name a name for the app
-	 * @param {String} root the root directory of the project. All other 
-	 *  paths will be relative to this path. 
-	 * @param {String} index the path to the main source file for the app. all 
+	 * @param {String} root the root directory of the project. All other
+	 *  paths will be relative to this path.
+	 * @param {String} index the path to the main source file for the app. all
 	 * 	source paths will be assumed to be relative to this path.
-	 * @param {String} dest the path to the destination folder for the 
+	 * @param {String} dest the path to the destination folder for the
 	 * 	rolled up files
 	 */
 
 	constructor(name, root, index , dest) {
-		root = fixPath(root);
+		root = this.fixPath(root);
 		this.root = root;
 
 		var filename = path.posix.join(root, index);
@@ -56,31 +56,55 @@ export class App {
 
 		this.name = name;
 		this.index = index;
+		this.fullIndexPath = path.posix.join(root, index);
+
 		this.loadables = [];
 		this.featureIndexes = [];
+		this.configs = {};
 	}
 
 	static fileToPath(filename) {
-		filename = fixPath(filename);
+		filename = this.fixPath(filename);
 		return path.posix.dirname(filename);
 	}
 
+	/**
+	 * call this method to force the file path to use posix notation and remove
+	 * all drive information.
+	 *
+	 *
+	 * @param {String} src the filename wqe
+	 * @returns {String} the new path
+	 */
+	static fixPath(src) {
+		src = src.replace('file:', '');
+		src = src.replace('///', '');
+		src = src.replace(/.:/, '');
+		src = src.replace(/\\/g, '/');
+
+		return src;
+	}
+
 	/**
 	 * Call this method to generate a path relative to the src directory
-	 * 
-	 * @param {String} path
+	 *
+	 * @param {String} fully qualified path
 	 * @returns the path relative to the source root.
 	 */
 	rootPath(path) {
 		var idx = path.indexOf(this.sourcePath);
-		if (idx === 0) path.splice(0, length(this.sourcePath));
-		if (path[0] === '/') path.splice(0, 1);
+		if (idx === 0) path = path.slice(this.sourcePath.length);
+		if (path[0] === '/') path = path.slice(1);
 
 		return './' + path;
 	}
 
-	setHtmlTemplate(template, target) {
-		this.htmlTemplate = {template, target};
+	setHtmlTemplate(source, destination) {
+		this.htmlTemplate = {source: source, destination: destination};
+	}
+
+	addConfig(config, root) {
+		this.configs[root] = config;
 	}
 
 	// default implementation, applications will implement this to specify the loadable features to be used
@@ -88,25 +112,46 @@ export class App {
 		return [];
 	}
 
-	async loadFeature(src) {
-		var featurePath = path.posix.join(this.sourcePath, src);
-		var indexPath = fixPath(path.posix.join(featurePath, 'index.js'))
-		var indexExists = await fs.pathExists(indexPath);
-		var builderPath = fixPath(path.posix.join(featurePath, 'build/index.js'));
-		var builderExists = await fs.pathExists(builderPath);
+	addFeatureMain(main) {
+		this.featureIndexes.push(main);
+	}
 
+	/**
+	 * Call this method to add the feature to the app. Features are isolated
+	 * pieces of code that are not a direct dependency of the main application.
+	 *
+	 * @param {String} root path relative to the source directory for the
+	 * feature to load.
+	 */
+	async loadFeature(root) {
+		var featurePath = path.posix.join(this.sourcePath, root);
+		var indexPath = path.posix.join(featurePath, 'index.js')
+		var builderPath = path.posix.join(featurePath, 'build.js');
+		var jsonPath = path.posix.join(featurePath, 'build.json');
+
+		var indexExists = await fileExists(indexPath);
+		var builderExists = await fileExists(builderPath);
+		var jsonExists = await fileExists(jsonPath);
+
+		// If there is a builder, we will use this
 		if (builderExists) {
 			try {
-				var module = await import(builderPath)
-				var feature = module.default;
+				let module = await import(builderPath)
+				let feature = module.default;
 				await feature.build(this);
 			} catch(e) {
-				console.error('error while building feature', src);
+				console.error('error while building feature', root);
 				console.log(e);
 			}
-		}
 
-		if (indexExists) this.featureIndexes.push(this.rootPath(indexPath));
+		// second priority is a build configuration file.
+		} else if (jsonExists) {
+			let content = readFile(jsonPath);
+			let builder = new ConfigFeature(content, featurePath);
+			await feature.build
+
+		// if neither exist, assume the index should be added
+		} else if (indexExists) this.featureIndexes.push(indexPath);
 	}
 
 	async buildFeatures() {
@@ -114,25 +159,26 @@ export class App {
 
 		for (let feature of features) {
 			await(this.loadFeature(feature));
-		}		
+		}
 	}
 
 	/* features will call this method if they want to add loadables
 
 	  name - name of the loadable that we be passed to the load method
-	  src - the path to the entry point of the loadable
-	  prefix - if given, the prefix on services created in this loadable. 
+	  main - the relative path from the source folder to the entry point of the
+	    loadable.
+	  prefix - if given, the prefix on services created in this loadable.
 	    The start and ready methods will be called on these services
 	*/
-	addLoadable(name, src, prefix) {
-		var dest = path.posix.join(this.sourcePath, src);
+	addLoadable(name, main, prefix) {
+		var dest = path.posix.join(this.sourcePath, main);
 
 		console.log(dest)
 		this.loadables.push({name, path: dest, prefix});
 	}
-	
+
 	buildConfiguration() {
-		var input = [this.index];
+		var input = [this.fullIndexPath];
 		this.loadables.forEach(function(path) {
 			input.push(path.path);
 		});
@@ -148,28 +194,28 @@ export class App {
 				plugins: [
 					resolve.nodeResolve({
 						extensions: ['.js', '.jsx']
-					}), 
-					commonjs(), 
+					}),
+					commonjs(),
 					babel({
 						presets: ['@babel/preset-react'],
 					}),
 					loader(this.loadables),
 					features(this.featureIndexes),
 					html({
-						include: path.join(this.sourcePath, "**/*.html"), 
+						include: path.join(this.sourcePath, "**/*.html"),
 					}),
-					styles(),					
+					styles(),
 					mainHTML({
 						root: this.root,
-						template: this.htmlTemplate.template,
-						target: this.htmlTemplate.target,
+						source: this.htmlTemplate.source,
+						destination: this.htmlTemplate.destination,
 						replaceVars: {},
 					})
 				],
 			},
 			output : {
 				output : {
-					sourcemap: true,					
+					sourcemap: true,
 					dir : this.destination,
 					format: 'es',
 				},
@@ -184,10 +230,11 @@ export class App {
 		await this.buildFeatures();
 		var config = this.buildConfiguration();
 
+		console.log(JSON.stringify(config, null, '    '));
+
 		const bundle = await rollup.rollup(config.input);
 		await bundle.generate(config.output);
 		await bundle.write(config.output);
 		await bundle.close();
 	}
 }
-

package/ConfigApp.js

@@ -0,0 +1,24 @@
+import {App} from './App';
+import path from 'node:path/posix';
+
+export default class ConfigApp extends App {
+    constructor (config, root) {
+        App.fixPath(root);
+        var name = config.name || 'unnamed';
+        var index = config.main || path.join(root, 'src', 'index.js');
+        var dest = config.dest || path.join(root, 'dist');
+
+        super(name, root, index, dest);
+        this.config = config;
+
+        if (!index.template || !index.template.source) throw new Error('html source not defined in config file');
+        var source = index.template.source;
+        var sourceFilename = path.basename(source);
+        var destination = index.template.destination || path.join(dest, sourceFilename)
+        this.setHtmlTemplate(source, destination)
+    }
+
+    async getFeatures() {
+        return this.config.features || [];
+    }
+}

package/ConfigFeature.js

@@ -0,0 +1,21 @@
+import Feature from './Feature';
+
+export default class Feature {
+    constructor (config, root) {
+        super();
+        this.config = config;
+        this.root = root;
+    }
+
+    async build(app) {
+        if (config.loadables && Array.isArray(config.loadables)) {
+            config.loadables.forEach(function(loadable) {
+                if (loadable.name && loadable.main) {
+                    app.addLoadable(loadable.name, loadable.main, loadable.prefix);
+                }
+            }, this);
+        }
+        if (config.main) app.addFeatureMain(config.main);
+        if (config.config) app.addConfig(config.config, this.root);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylith/builder",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "The polylith builder",
   "main": "index.js",
   "type": "module",
@@ -22,7 +22,7 @@
     "rollup": "^2.58.0",
     "rollup-plugin-html": "^0.2.1",
     "rollup-plugin-jsx": "^1.0.3",
-    "rollup-plugin-styles": "^3.14.1",
+    "rollup-plugin-styles": "^4.0.0",
     "sass": "^1.43.4"
   }
 }

package/plugin-features.js

@@ -2,12 +2,11 @@ function makeSource(features) {
 
     var importStatements = '';
 	features.forEach(function(feature) {
-        importStatements += `import from '${feature}'\n`;
+        importStatements += `import '${feature}'\n`;
     })
 
 	var source = `${importStatements}`
 
-	console.log(source);
 	return source;
 }
 

package/plugin-main-html.js

@@ -1,6 +1,7 @@
 import escapeStringRegexp from 'escape-string-regexp';
-import fs from 'fs-extra';
+import {ensureFile} from 'fs-extra';
 import path from 'path/posix';
+import {readFile, writeFile} from 'node:fs/promises';
 
 const INVALID_ARGS_ERROR =
   "[plugin-main-html] You did not provide a template or target!";
@@ -22,20 +23,19 @@ function createScriptTags(scripts) {
 }
 
 export default function(options = {}) {
-  var { root, template, target, replaceVars } = options;
+  var { root, source, destination, replaceVars } = options;
   
   return {
     name: "main-html-template",
 
     async generateBundle(outputOptions, bundleInfo) {
-//        console.log(JSON.stringify(bundleInfo, null, '  '));
 		return new Promise(async function (resolve, reject) {
 			try {
 				var includes = [];
 				var names = Object.keys(bundleInfo);
 				var scripts;
 		
-				if (!target && !template) throw new Error(INVALID_ARGS_ERROR);
+				if (!destination && !source) throw new Error(INVALID_ARGS_ERROR);
 
 				names.forEach(function(name) {
 					var entry = bundleInfo[name];
@@ -47,15 +47,11 @@ export default function(options = {}) {
 				scripts = createScriptTags(includes);
 				replaceVars["scripts"] = scripts;
 
-				var templateFilePath = path.join(root, template);
-				var targetFilePath = path.join(root, target);
+				var sourceFilePath = path.join(root, source);
+				var destinationFilePath = path.join(root, destination);
 
 				// Read the file
-				var buffer = await fs.readFile(templateFilePath);
-
-				// Convert buffer to a string and replace the replaceable 
-				// variables
-				var content = buffer.toString("utf8");
+				var content = await readFile(sourceFilePath, 'utf-8');
 				if (replaceVars) {
 					var varNames = Object.keys(replaceVars);
 					varNames.forEach(function(name) {
@@ -66,11 +62,9 @@ export default function(options = {}) {
 					});
 				}
 
-				var injected = content;
-
 				// write the injected template to a file
-				await fs.ensureFile(targetFilePath);
-				await fs.writeFile(targetFilePath, injected);
+				await ensureFile(destinationFilePath);
+				writeFile(destinationFilePath, content, 'utf-8');
 				resolve();
 			} catch (e) {
 				reject(e);

package/plugin-config.js

@@ -1,23 +0,0 @@
-
-import rollupPluginutils from ('rollup-pluginutils');
-
-
-export default function config() {
-	var opts = {};
-
-	opts.include = '**/*.cfg'
-
-	var filter = rollupPluginutils.createFilter(opts.include, opts.exclude);
-
-	return {
-		name: 'config', 
-
-		async load(id) {
-			if (filter(id)) {
-				console.log(id);
-				return source;
-            }
-		}
-	};
-}
-