polylith 0.1.75 → 0.1.76

package/bin/apps.js

@@ -25,17 +25,15 @@ function findDefaultApp(config) {
  *
  * @param {String} name the app name specified from the command line
  * @param {Object} config the current polylith configuration object
- * @param {Object} options the options from the command line
  *
  * @returns {Array} the list of object specs to act on
  */
-export function getAppSpecs(name, config, options) {
+export function getAppSpecs(name, config) {
 	var specs = [];
 	var foundSpec;
-	var apps = [];
 	var defaultApp = findDefaultApp(config);
 
-	if (options.all) {
+	if (config.all) {
 		specs = config.apps;
 	} else if (!name) {
 		if (!defaultApp) {
@@ -76,26 +74,26 @@ async function readJson(filename) {
 /**
  * Call this method to get the App object from the given app spec.
  *
- * @param {Object} spec the application spec from the poilylith configuration
+ * @param {Object} spec the application spec from the polylith configuration
  * 		object
- * @param {Object} options the command line options
+ * @param {Object} config the polylith configuration object
  *
  * @returns {App|Boolean} the application object, false if there ws an error
  */
-async function getApp(spec, options) {
-	var buildPath = path.join(workingDir(), options.builds);
+async function getApp(spec, config) {
+	var buildPath = path.join(workingDir(), config.builds);
 	var filename = path.join(buildPath, spec.filename);
 	var app;
 
 	if (!spec.code) {
 		var config = await(readJson(filename));
 		if (!config) return false;
-		app = new ConfigApp(config, workingDir());
+		app = new ConfigApp(spec, config, workingDir());
 	} else {
 		try {
 			var res = await import(filename);
 			if (!res.default) throw new Error('no default in application module')
-			app = res.default;
+			app = new res.default(config);
 			if (!app.build && app.watch) throw new Error('application file is not an application module');
 		} catch(e) {
 			console.warn(`error loading app ${spec.name}`);
@@ -106,13 +104,13 @@ async function getApp(spec, options) {
 	return app;
 }
 
-async function walkApps(name, config, options, cb) {
-	var specs = getAppSpecs(name, config, options);
+async function walkApps(name, config, cb) {
+	var specs = getAppSpecs(name, config);
 	var apps = [];
 
 	// using for loop because we are making async calls
 	for (let spec of specs) {
-		let app = await getApp(spec, options);
+		let app = await getApp(spec, config);
 		if (!app) continue;
 
 		if (!cb || await cb(app)) apps.push(app)
@@ -125,14 +123,13 @@ async function walkApps(name, config, options, cb) {
  * Call this method to build all the applications specified on the command line
  *
  * @param {String} name the name of the application from the command line
- * @param {Object} config the polylith config object
- * @param {Object} options the options from the command line
+ * @param {Object} config the polylith config
  * @param {Boolean} watch true if building for watch mode
  *
  * @returns {Promise.<Array.<App>>} the list of built apps
  */
-export async function build(name, config, options, watch) {
-	var apps = await walkApps(name, config, options, async function(app) {
+export async function build(name, config, watch) {
+	var apps = await walkApps(name, config, async function(app) {
 		app.setLiveReload(watch);
 		return await app.build();
 	})
@@ -140,46 +137,45 @@ export async function build(name, config, options, watch) {
 	return apps;
 }
 
-async function server(options) {
-	var server = new PolylithServer(options, options.dest);
-	await server.create(options.apps);
-	server.start(options.port || '8081');
+async function server(config) {
+	var server = new PolylithServer(config, config.dest);
+	await server.create(config.apps);
+	server.start(config.port || '8081');
 }
 
-export async function watch(name, config, options) {
-	var apps = await build(name, config, options, true);
+export async function watch(name, config) {
+	var apps = await build(name, config, true);
 
 	for (let app of apps) {
 		await app.watch();
 	}
 
-	if (options.serve)
-		await server({...options, apps: apps});
+	if (config.serve)
+		await server({...config, apps: apps});
 }
 
-export async function run(name, config, options) {
-	var apps = await build(name, config, options, false);
+export async function run(name, config) {
+	var apps = await build(name, config, false);
 
-	await server({...options, apps: apps});
+	await server({...config, apps: apps});
 }
 
-export async function serve(name, config, options) {
-	var apps = await walkApps(name, config, options);
+export async function serve(name, config) {
+	var apps = await walkApps(name, config);
 
-	await server({...options, apps: apps});
+	await server({...config, apps: apps});
 }
 
-export async function test(name, config, options) {
-	var apps = await walkApps(name, config, options, async function(app) {
+export async function test(name, config) {
+	var apps = await walkApps(name, config, async function(app) {
 		return await app.test();
 	})
 
-	if (options.watch) {
+	if (config.watch) {
 		for (let app of apps) {
 			app.watch();
 		}
 	}
 
 	return apps;
-
 }

package/bin/polylith.js

@@ -27,6 +27,8 @@ var clOptions = {
 	serve: true,
 }
 
+var polylithConfig = {};
+
 var thisDir = path.dirname(forceToPosix(import.meta.url));
 
 /**
@@ -70,7 +72,7 @@ function checkBoolean(val) {
 function getOption(name, short) {
 	if (argv[name] !== undefined) return checkBoolean(argv[name]);
 	if (argv[short] != undefined) return checkBoolean(argv[short]);
-	return clOptions[name];
+	return polylithConfig[name];
 }
 
 /**
@@ -160,21 +162,21 @@ async function writeConfig(config) {
 async function getOptions() {
 	var config = await readConfig();
 
-	clOptions = {...clOptions, ...config};
+	polylithConfig = {...clOptions, ...config};
 
-	clOptions.multiple = getOption('multiple', 'm');
-	clOptions.dest = getOption('dest', 'd');
-	clOptions.src = getOption('src', 's')
-	clOptions.builds = getOption('builds', 'b')
-	clOptions.all = getOption('all', 'a')
-	clOptions.code = getOption('code', 'c')
-	clOptions.index = getOption('index', 'i')
-	clOptions.react = getOption('react', 'r')
-	clOptions.watch = getOption('watch', 'w')
-	clOptions.serve = getOption('serve', 'v')
+	polylithConfig.multiple = getOption('multiple', 'm');
+	polylithConfig.dest = getOption('dest', 'd');
+	polylithConfig.src = getOption('src', 's')
+	polylithConfig.builds = getOption('builds', 'b')
+	polylithConfig.all = getOption('all', 'a')
+	polylithConfig.code = getOption('code', 'c')
+	polylithConfig.index = getOption('index', 'i')
+	polylithConfig.react = getOption('react', 'r')
+	polylithConfig.watch = getOption('watch', 'w')
+	polylithConfig.serve = getOption('serve', 'v')
 
 	// force multiple if we already have more than one app;
-	if (config.apps && config.apps.length > 1) clOptions.multiple = true;
+	if (config.apps && config.apps.length > 1) polylithConfig.multiple = true;
 }
 
 /**
@@ -292,7 +294,7 @@ function getNames(params) {
 	var app = '';
 	var name = '';
 
-	if (clOptions.multiple && !clOptions.all) {
+	if (polylithConfig.multiple && !polylithConfig.all) {
 		app = params[1];
 		name = params[2];
 	} else {
@@ -320,11 +322,11 @@ function getNames(params) {
 		names.name = name;
 	}
 
-	names.dest = clOptions.dest;
-	names.builds = clOptions.builds;
-	names.src = clOptions.src;
-	names.react = clOptions.react;
-	names.path = clOptions.multiple ? '/' + app : '';
+	names.dest = polylithConfig.dest;
+	names.builds = polylithConfig.builds;
+	names.src = polylithConfig.src;
+	names.react = polylithConfig.react;
+	names.path = polylithConfig.multiple ? '/' + app : '';
 
 	return names;
 }
@@ -344,8 +346,8 @@ async function runInstall() {
  * @returns {Boolean} true if the number of parameters is correct
  */
 function verifyParams() {
-	var multiple = clOptions.multiple;
-	var all = clOptions.all;
+	var multiple = polylithConfig.multiple;
+	var all = polylithConfig.all;
 	var command = params[0];
 
 	if (!command) return false;
@@ -384,7 +386,7 @@ async function addAppJson(names, options) {
 }
 
 /**
- * Call this method to test that the instance of polylith being run is  local to
+ * Call this method to test that the instance of polylith being run is local to
  * the current project
  *
  * @returns {Boolean} true if the instance is local
@@ -394,11 +396,10 @@ function checkLocalPolylith() {
 }
 
 /**
- * Call this function to execure the command from the command line
+ * Call this function to execute the command from the command line
  */
 async function execute() {
 	await getOptions();
-	var config = await readConfig();
 
 	if (!verifyParams() || argv.help || argv.h) {
 		await outputInstructions();
@@ -409,45 +410,45 @@ async function execute() {
 	{
 		case 'init': {
 			let names = getNames(params);
-			await processManifest('install', names, clOptions);
+			await processManifest('install', names, polylithConfig);
 			await runInstall();
 			break;
 		}
 
 		case 'app': {
 			let names = getNames(params);
-			await processManifest('app', names, clOptions);
-			await addAppJson(names, clOptions);
+			await processManifest('app', names, polylithConfig);
+			await addAppJson(names, polylithConfig);
 			break;
 		}
 
 		case 'feature': {
 			let names = getNames(params);
-			processManifest('feature', names, clOptions);
+			processManifest('feature', names, polylithConfig);
 			break;
 		}
 
 		case 'build': {
-			await build(params[1], config, clOptions, false);
+			await build(params[1], polylithConfig, false);
 			break;
 		}
 
 		case 'watch': {
-			await watch(params[1], config, clOptions)
+			await watch(params[1], polylithConfig)
 			break;
 		}
 
 		case 'test': {
-			await test(params[1], config, clOptions)
+			await test(params[1], polylithConfig)
 			break;
 		}
 
 		case 'run': {
-			await run(params[1], config, clOptions)
+			await run(params[1], polylithConfig)
 		}
 
 		case 'serve' : {
-			await serve(params[1], config, clOptions)
+			await serve(params[1], polylithConfig)
 		}
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polylith",
-  "version": "0.1.75",
+  "version": "0.1.76",
   "description": "cli for the polylith environment",
   "bin": {
     "polylith": "bin/polylith.js"
@@ -17,7 +17,7 @@
   "author": "Glenn Anderson",
   "license": "MIT",
   "dependencies": {
-    "@polylith/builder": "0.2.21",
+    "@polylith/builder": "0.2.22",
     "@polylith/server": "0.1.25",
     "fs-extra": "^10.1.0",
     "minimist": "^1.2.7"