@polylith/builder 0.0.23 → 0.0.25

package/App.js

@@ -1,55 +1,53 @@
-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 config from './plugin-config.js';
 import styles from "rollup-plugin-styles";
 
+import ConfigFeature from './ConfigFeature.js';
 
 /**
- * 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;
+    }
 }
 
 /**
  * The base class for applications. Applications inherit from this class
  */
-export class App {
+export default 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 = App.fixPath(root);
 		this.root = root;
 
 		var filename = path.posix.join(root, index);
@@ -62,17 +60,35 @@ export class App {
 
 		this.loadables = [];
 		this.featureIndexes = [];
+		this.configs = {};
 	}
 
 	static fileToPath(filename) {
-		filename = fixPath(filename);
+		filename = App.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) {
@@ -83,8 +99,12 @@ export class App {
 		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
@@ -92,25 +112,52 @@ 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(indexPath);
+		// second priority is a build configuration file.
+		} else if (jsonExists) {
+			try {
+				let content = JSON.parse(await readFile(jsonPath));
+
+				let builder = new ConfigFeature(content, featurePath);
+				await builder.build(this)
+			} catch (e) {
+				console.error(e);
+				throw e;
+			}
+
+		// if neither exist, assume the index should be added
+		} else if (indexExists) this.featureIndexes.push(indexPath);
 	}
 
 	async buildFeatures() {
@@ -118,23 +165,24 @@ 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)
+		console.log('addLoadable', {name, path: dest, prefix})
 		this.loadables.push({name, path: dest, prefix});
 	}
-	
+
 	buildConfiguration() {
 		var input = [this.fullIndexPath];
 		this.loadables.forEach(function(path) {
@@ -152,33 +200,52 @@ export class App {
 				plugins: [
 					resolve.nodeResolve({
 						extensions: ['.js', '.jsx']
-					}), 
-					commonjs(), 
+					}),
+					commonjs(),
 					babel({
 						presets: ['@babel/preset-react'],
 					}),
 					loader(this.loadables),
 					features(this.featureIndexes),
-					config(),					
 					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',
+					assetFileNames: function(chunkInfo) {
+						return '[name]-[hash][extname]';
+					},
+					entryFileNames: function(chunkInfo) {
+						var entry = App.fixPath(chunkInfo.facadeModuleId);
+						var found = this.loadables.find(function(loadable) {
+							return loadable.path === entry;
+						}, this);
+						var exists = Boolean(found);
+
+						if (exists) return (`${found.name}.js`);
+						if (entry === this.fullIndexPath) {
+							return `${this.name}.js`
+						}
+						return '[name].js';
+					}.bind(this),
+					manualChunks: function(id) {
+						if (id.includes('node_modules')) {
+							return 'vendor';
+						}
+					}
 				},
-				assetFileNames: "[name]-[hash][extname]",
 			}
 		};
 
@@ -189,12 +256,9 @@ 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,23 @@
+import Feature from './Feature.js';
+
+export default class ConfigFeature extends Feature {
+    constructor (config, root) {
+        super();
+        this.config = config;
+        this.root = root;
+    }
+
+    async build(app) {
+        var config = this.config;
+
+        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/Feature.js

@@ -1,8 +1,8 @@
-export class Feature {
+export default class Feature {
   constructor () {
   }
 
   async build(app) {
     this.app = app;
   }
-}
+}

package/index.js

@@ -1,4 +1,4 @@
-import {App} from './App.js'
-import {Feature} from './Feature.js';
+import App from './App.js'
+import Feature from './Feature.js';
 
-export {App as App, Feature as Feature};
+export {App as App, Feature as Feature};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylith/builder",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "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-loader.js

@@ -15,14 +15,14 @@ function makeSource(loadables) {
 		}
 
 		var switchStr = `
-			case '${loadable.name}': 
+			case '${loadable.name}':
 				promise = import('${loadable.path}')${prefixStr}
 				break;
-` 
+`
 		loadableSwitches += switchStr;
 	})
 
-	var source = 
+	var source =
 `
 	import {registry} from '@polylith/core';
 
@@ -35,14 +35,12 @@ ${loadableSwitches}
 		return promise;
 	}
 `
-	console.log(source);
 	return source;
 }
 
-
 export default function loader(loadables) {
 	return {
-		name: 'loader', 
+		name: 'loader',
 
 		resolveId (source, _, third) {
 			if (source === '@polylith/loader') {
@@ -59,4 +57,3 @@ export default function loader(loadables) {
 		}
 	};
 }
-

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,29 +0,0 @@
-
-import rollupPluginutils from ('rollup-pluginutils');
-
-
-export default function config() {
-	var opts = {};
-
-	opts.include = '**/*.pl-cfg'
-
-	var filter = rollupPluginutils.createFilter(opts.include, opts.exclude);
-
-	return {
-		name: 'config', 
-
-		resolveId (source, _, third) {
-			if (filter(source)) return source
-
-			return null;
-		},
-
-		async load(id) {
-			if (filter(id)) {
-				console.log(id);
-				return '';
-			}
-		}
-	};
-}
-