@polylith/builder 0.0.18 → 0.0.19

package/App.js

@@ -6,41 +6,69 @@ import * as resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import html from "rollup-plugin-html";
 
-import loadables from './plugin-loadables.js';
+import loader from './plugin-loader.js';
 import mainHTML from './plugin-main-html.js';
+import features from './plugin-feature.js';
 import styles from "rollup-plugin-styles";
 
-export class App {
-	/* 
-		srcDir - the path to the calling app. This is necessary to resolve file paths
-		name - a name for the app
-		appEntry - the path to the main source file for the app
-		destination - the path to the destination folder for the rolled up files
-
-		All paths are relative to srcDir
-	*/
+/**
+ * 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
+ */
+function fixPath(src) {
+	src = src.replace('file:', '');
+	src = src.replace('///', '');
+	src = src.replace(/.:/, '');
+	src = src.replace(/\\/g, '/');
+
+	return src;
+}
 
-	constructor(srcDir, name, appEntry, destination) {
-		this.srcDir = this.fixPath(srcDir);
-		var parts = path.posix.parse(this.srcDir);
-		var root = parts.dir;
-		var filename = path.posix.join(root, appEntry);
-		this.basePath = path.posix.dirname(filename);
-		this.destination = path.posix.join(root, destination);
+/**
+ * The base class for applications. Applications inherit from this class
+ */
+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 
+	 * 	source paths will be assumed to be relative to this path.
+	 * @param {String} dest the path to the destination folder for the 
+	 * 	rolled up files
+	 */
+
+	constructor(name, root, index , dest) {
+		root = fixPath(root);
+		var filename = path.posix.join(root, index);
+		this.sourcePath = path.posix.dirname(filename);
+		this.destination = path.posix.join(root, dest);
 
 		this.name = name;
-		this.appEntry = appEntry;
+		this.index = index;
 		this.loadables = [];
+		this.root = root;
 	}
 
-	// make all paths on the same drive, this is to clean up windows paths
-	fixPath(src) {
-		src = src.replace('file:', '');
-		src = src.replace('///', '');
-		src = src.replace(/.:/, '');
-		src = src.replace(/\\/g, '/');
+	static fileToPath(filename) {
+		filename = fixPath(filename);
+		return path.posix.dirname(filename);
+	}
+
+	/**
+	 * Call this method to generate a path relative to the src directory
+	 * 
+	 * @param {String} path
+	 */
+	rootPath(path) {
 
-		return src;
 	}
 
 	setHtmlTemplate(template, target) {
@@ -53,24 +81,30 @@ export class App {
 	}
 
 	async loadFeature(src) {
-		var featurePath = path.posix.join(this.basePath, src);
-		var featureModule = this.fixPath(path.posix.join(featurePath, 'build/index.js'));
-
-		try {
-			return import(featureModule).then(function(module) {;
+		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);
+
+		if (builderExists) {
+			try {
+				var module = await import(builderPath)
 				var feature = module.default;
-				feature.build(this);
-			}.bind(this))
-		} catch(e) {
-			console.error('error while building feature', src);
-			console.log(e);
+				await feature.build(this);
+			} catch(e) {
+				console.error('error while building feature', src);
+				console.log(e);
+			}
 		}
+
+		if (indexExists) this.featureIndexes.push(indexPath);
 	}
 
 	async buildFeatures() {
 		var features = await this.getFeatures();
 
-		for (const feature of features) {
+		for (let feature of features) {
 			await(this.loadFeature(feature));
 		}		
 	}
@@ -83,21 +117,21 @@ export class App {
 	    The start and ready methods will be called on these services
 	*/
 	addLoadable(name, src, prefix) {
-		var dest = path.posix.join(this.basePath, src);
+		var dest = path.posix.join(this.sourcePath, src);
 
 		console.log(dest)
 		this.loadables.push({name, path: dest, prefix});
 	}
 	
 	buildConfiguration() {
-		var input = [this.appEntry];
+		var input = [this.index];
 		this.loadables.forEach(function(path) {
 			input.push(path.path);
 		});
 
 		this.variables = {
 			pattern: 'main-js',
-			replacement: `<script type="module" src="${this.appEntry}"></script>`
+			replacement: `<script type="module" src="${this.index}"></script>`
 		}
 
 		var config = {
@@ -111,12 +145,13 @@ export class App {
 					babel({
 						presets: ['@babel/preset-react'],
 					}),
-					loadables(this.loadables),
+					loader(this.loadables),
 					html({
-						include: path.join(this.basePath, "**/*.html"), 
+						include: path.join(this.sourcePath, "**/*.html"), 
 					}),
 					styles(),					
 					mainHTML({
+						root: this.root,
 						template: this.htmlTemplate.template,
 						target: this.htmlTemplate.target,
 						replaceVars: {},

package/Feature.js

@@ -2,7 +2,7 @@ export class Feature {
   constructor () {
   }
 
-  build(app) {
+  async build(app) {
     this.app = app;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylith/builder",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "The polylith builder",
   "main": "index.js",
   "type": "module",

package/plugin-config.js

@@ -0,0 +1,23 @@
+
+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;
+            }
+		}
+	};
+}
+	

package/{plugin-loadables.js → plugin-loader.js}

@@ -40,19 +40,19 @@ ${loadableSwitches}
 }
 
 
-export default function features(loadables) {
+export default function loader(loadables) {
 	return {
-		name: 'features', 
+		name: 'loader', 
 
-		resolveId ( source, _, third ) {
-			if (source === '@polylith/loadables') {
+		resolveId (source, _, third) {
+			if (source === '@polylith/loader') {
 				return source;
 			}
 			return null;
 		},
 
-		load ( id ) {
-			if (id === '@polylith/loadables') {
+		load (id) {
+			if (id === '@polylith/loader') {
 				return makeSource(loadables);
 			}
 			return null;

package/plugin-main-html.js

@@ -1,12 +1,6 @@
-/*
-var escapeStringRegexp = require('escape-string-regexp');
-var fs = require('fs-extra');
-var path = require('path');
-*/
-
 import escapeStringRegexp from 'escape-string-regexp';
 import fs from 'fs-extra';
-import path from 'path';
+import path from 'path/posix';
 
 const INVALID_ARGS_ERROR =
   "[plugin-main-html] You did not provide a template or target!";
@@ -28,7 +22,8 @@ function createScriptTags(scripts) {
 }
 
 export default function(options = {}) {
-  var { template, target, replaceVars } = options;
+  var { root, template, target, replaceVars } = options;
+  
   return {
     name: "main-html-template",
 
@@ -42,11 +37,6 @@ export default function(options = {}) {
 		
 				if (!target && !template) throw new Error(INVALID_ARGS_ERROR);
 
-				var outputDir = outputOptions.dir || path.dirname(outputOptions.file);
-
-				var targetDir = outputDir;
-				var bundleDirString = "";
-
 				names.forEach(function(name) {
 					var entry = bundleInfo[name];
 					if (!entry.isDynamicEntry) {
@@ -57,40 +47,30 @@ export default function(options = {}) {
 				scripts = createScriptTags(includes);
 				replaceVars["scripts"] = scripts;
 
-				if (target && path.dirname(target) !== ".") {
-					targetDir = path.dirname(target);
-					var bundleDir = path.relative(targetDir, outputDir);
-					bundleDirString = bundleDir && `${bundleDir}/`;
-				}
-
-				// Get the target file name.
-				var targetName = path.basename(target || template);
-
-				// Add the file suffix if it isn't there.
-				var targetFile =
-					targetName.indexOf(".html") < 0 ? `${targetName}.html` : targetName;
+				var templateFilePath = path.join(root, template);
+				var targetFilePath = path.join(root, target);
 
 				// Read the file
-				var buffer = await fs.readFile(template);
+				var buffer = await fs.readFile(templateFilePath);
 
-				// Convert buffer to a string and get the </body> index
-				var tmpl = buffer.toString("utf8");
+				// Convert buffer to a string and replace the replaceable 
+				// variables
+				var content = buffer.toString("utf8");
 				if (replaceVars) {
-					var patterns = Object.keys(replaceVars);
-					patterns.forEach(function(pattern) {
-						var replacement = replaceVars[pattern]
-						var escapedPattern = escapeStringRegexp('${' + pattern + '}');
-						var regex = new RegExp(`${escapedPattern}`, 'g');
-						tmpl = tmpl.replace(regex, replacement);
+					var varNames = Object.keys(replaceVars);
+					varNames.forEach(function(name) {
+						var replacement = replaceVars[name]
+						var escapedName = escapeStringRegexp('${' + name + '}');
+						var regex = new RegExp(escapedName, 'g');
+						content = content.replace(regex, replacement);
 					});
 				}
 
-				var injected = tmpl;
+				var injected = content;
 
 				// write the injected template to a file
-				var finalTarget = path.join(targetDir, targetFile);
-				await fs.ensureFile(finalTarget);
-				await fs.writeFile(finalTarget, injected);
+				await fs.ensureFile(targetFilePath);
+				await fs.writeFile(targetFilePath, injected);
 				resolve();
 			} catch (e) {
 				reject(e);