lincd-cli 0.1.23 → 0.1.24

package/defaults/app-with-backend/package.json

@@ -4,9 +4,9 @@
   "description": "",
   "version": "0.1.0",
   "private": true,
-  "author":{
-    "name" : "",
-    "url" : "",
+  "author": {
+    "name": "",
+    "url": "",
     "email": ""
   },
   "engines": {
@@ -50,6 +50,7 @@
     "@types/react-dom": "^18.0.6",
     "env-cmd": "^10.1.0",
     "lincd-cli": "^0.1",
-    "nodemon": "^2.0.6"
+    "nodemon": "^2.0.6",
+    "ts-loader": "^9.4.1"
   }
 }

package/defaults/module/package.json

@@ -16,8 +16,8 @@
   "types": "dist/${output_file_name}.d.ts",
   "license": "ISC",
   "scripts": {
+    "start": "npm exec lincd dev",
     "build": "npm exec lincd build",
-    "dev": "npm exec lincd dev",
     "prepublishOnly": "npm exec lincd build production",
     "postpublish": "npm exec lincd register"
   },

package/lib/cli.js

@@ -72,6 +72,7 @@ var path = require('path');
 var glob = require('glob');
 var variables = {};
 var open = require('open');
+var gruntConfig;
 program
     .command('create-app')
     .action(function (name) {
@@ -84,15 +85,15 @@ program
     .action(function (name, uriBase) {
     return createModule(name, uriBase);
 })
-    .description('Create a new folder with all the required files for a new LINCD module')
-    .argument('<name>', 'The name of the module. Will be used as package name in package.json')
-    .argument('[uri_base]', 'The base URL used for data of this module. Leave blank to use the URL of your module on lincd.org after you register it');
+    .description('Create a new folder with all the required files for a new LINCD package')
+    .argument('<name>', 'The name of the package. Will be used as package name in package.json')
+    .argument('[uri_base]', 'The base URL used for data of this package. Leave blank to use the URL of your package on lincd.org after you register it');
 program
     .command('create-shape')
     .action(function (name, uriBase) {
     return createShape(name);
 })
-    .description('Creates a new ShapeClass file for your module. Execute this from your module folder.')
+    .description('Creates a new ShapeClass file for your package. Execute this from your package folder.')
     .argument('<name>', 'The name of the shape. Will be used for the file name and the class name');
 program
     .command('create-component')
@@ -106,9 +107,9 @@ program
     .action(function (prefix, uriBase) {
     return createOntology(prefix, uriBase);
 })
-    .description('Creates a new ontology file for your module. Execute this from your module folder.')
+    .description('Creates a new ontology file for your package. Execute this from your package folder.')
     .argument('<suggested-prefix>', 'The suggested prefix for your ontology. Also the shorthand code used for the file name and the exported ontology object')
-    .argument('[uribase]', "Optional argument to set the URI base for the URI's of all entities in your ontology. Leave blank to use the URI's provided by lincd.org once you register this module");
+    .argument('[uribase]', "Optional argument to set the URI base for the URI's of all entities in your ontology. Leave blank to use the URI's provided by lincd.org once you register this package");
 program.command('register-local', { hidden: true }).action(function () {
     register('http://localhost:4101');
 });
@@ -120,7 +121,7 @@ program
     .action(function () {
     register('https://registry.lincd.org');
 })
-    .description('Register (a new version of) this module to the LINCD registry. If successful your module will appear on www.lincd.org');
+    .description('Register (a new version of) this package to the LINCD registry. If successful your package will appear on www.lincd.org');
 program
     .command('info')
     .action(function () {
@@ -136,7 +137,9 @@ program.command('publish-updated').action(function () {
     return publishUpdated();
 });
 program.command('status').action(function () {
+    //log which packages need to be published
     return publishUpdated(true).then(function () {
+        //log which packages need to be build
         return buildUpdated(undefined, '', '', true);
     });
 });
@@ -149,17 +152,17 @@ program.command('build-updated-since [num-commits-back] [target] [target2]').act
 program.command('build-all [target] [target2]').action(function (target, target2) {
     buildAll(target, target2);
 });
-program.command('modules [action] [filter] [filter-value]').action(function (command, filter, filterValue) {
+program.command('all [action] [filter] [filter-value]').action(function (command, filter, filterValue) {
     executeCommandForEachModule(getLincdModules(), command, filter, filterValue);
 });
-// program.command('modules-except [excludedSpaces] [action]').action((excludedSpaces, command) => {
+// program.command('all-except [excludedSpaces] [action]').action((excludedSpaces, command) => {
 //   executeCommandForEachModule(getLincdModules(), command, null, excludedSpaces);
 // });
 program.command('dev [target] [mode]').action(function (target, mode) {
     developModule(target, mode);
 });
 program
-    .command('module|m')
+    .command('module|m|package|p')
     .action(function (name, command, args) {
     var fullCommand = command
         ? command +
@@ -173,8 +176,8 @@ program
     executeCommandForModule(name, fullCommand);
 })
     .alias('m')
-    .description("Searches for a module in this workspace with a partially matching name and executes a command for that module (without needing to execute it from that modules' folder)")
-    .argument('<name>', 'the name of the module. Can be a part of the name.')
+    .description('Searches for a package in this workspace with a partially matching name and executes a command for that package (without needing to execute it from the folder of the package)')
+    .argument('<name>', 'the name of the package. Can be a part of the name.')
     .argument('[command]', 'the lincd command you want to execute. Like dev or build')
     .argument('[args...]', 'the additional arguments of that command');
 function logHelp() {
@@ -189,6 +192,33 @@ function log() {
         console.log(chalk.cyan('Info: ') + message);
     });
 }
+function progressUpdate(message) {
+    process.stdout.write('                                                                    \r');
+    process.stdout.write(message + '\r');
+}
+function debugInfo() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    // messages.forEach((message) => {
+    //   console.log(chalk.cyan('Info: ') + message);
+    // });
+    //@TODO: let packages also use lincd.config.json? instead of gruntfile...
+    // that way we can read "analyse" here and see if we need to log debug info
+    // if(!gruntConfig)
+    // {
+    //   gruntConfig = getGruntConfig();
+    //   console.log(gruntConfig);
+    //   process.exit();
+    // }
+    // if(gruntConfig.analyse === true)
+    // {
+    //   messages.forEach((message) => {
+    //     console.log(chalk.cyan('Info: ') + message);
+    //   });
+    // }
+}
 function warn() {
     var messages = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -246,7 +276,7 @@ function checkModulePath(rootPath, modulePath, res) {
     // console.log('checking '+packagePath);
     if (fs.existsSync(packagePath)) {
         var pack = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-        //some packages are not true lincd modules, but we still want them to be re-built automatically. This is what lincd_util is for
+        //some packages are not true lincd packages, but we still want them to be re-built automatically. This is what lincd_util is for
         if (pack && pack.workspaces) {
             checkWorkspaces(modulePath, pack.workspaces, res);
         }
@@ -259,221 +289,240 @@ function checkModulePath(rootPath, modulePath, res) {
         }
     }
 }
-function buildAll(target, target2) {
+function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd) {
     var _this = this;
     var dependencies = new Map();
-    console.log('Building all modules of this repository in order of dependencies');
-    var modules = getLocalLincdModuleMap();
-    //get dependencies of each module
+    //get dependencies of each package
     var leastDependentModule;
-    modules.forEach(function (module) {
-        var pack = (0, utils_1.getPackageJSON)(module.path);
+    lincdPackages.forEach(function (pkg) {
+        var pack = (0, utils_1.getPackageJSON)(pkg.path);
         if (pack) {
-            //get lincd related dependencies and get the actual module details from the module map by removing '@dacore/' from the package name
+            //get lincd related dependencies and get the actual package details from the package map by removing '@dacore/' from the package name
             var moduleDependencies = Object.keys(pack.dependencies)
-                .filter(function (dependency) { return modules.has(dependency); })
+                .filter(function (dependency) { return lincdPackages.has(dependency); })
                 .map(function (dependency) {
-                return modules.has(dependency) ? modules.get(dependency) : dependency;
+                return lincdPackages.has(dependency) ? lincdPackages.get(dependency) : dependency;
             });
-            // console.log(module.moduleName,moduleDependencies.map())
-            dependencies.set(module, moduleDependencies);
+            // console.log(package.moduleName,moduleDependencies.map())
+            dependencies.set(pkg, moduleDependencies);
         }
     });
-    dependencies.forEach(function (moduleDependencies, module) {
+    dependencies.forEach(function (moduleDependencies, pkg) {
         if (!moduleDependencies.some(function (dependency) {
-            return typeof dependency !== 'string' && modules.has(dependency.moduleName);
+            return typeof dependency !== 'string' && lincdPackages.has(dependency.moduleName);
         })) {
-            leastDependentModule = module;
+            leastDependentModule = pkg;
         }
     });
-    var startFrom;
-    //by default start building
-    var building = true;
-    //option to start from a specific module in the stack
-    if (target == 'from') {
-        startFrom = target2;
-        //if we have a startFrom, then we havnt started the build process yet
-        building = startFrom ? false : true;
-        //clear targets
-        target = '';
-        target2 = '';
-        console.log(chalk.blue('Will skip builds until ' + startFrom));
-    }
-    var stack = [leastDependentModule];
+    var startStack = [leastDependentModule];
     var done = new Set();
-    var p = Promise.resolve();
-    var runStack = function () { return __awaiter(_this, void 0, void 0, function () {
-        var modulesLeft, failedModules, stackPromise, first_1;
+    var results = [];
+    var runStack = function (stack) { return __awaiter(_this, void 0, void 0, function () {
+        var runFunction, stackPromise, stackResults;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    modulesLeft = modules.size - done.size;
-                    if (done.size > 0) {
-                        console.log(chalk.magenta('\n-------\nThese modules are next, since all their dependencies have now been build:'));
-                        console.log(chalk.magenta(stack.map(function (i) { return i.moduleName; })));
-                        // log(stack);
-                    }
-                    failedModules = [];
-                    stackPromise = Promise.all(stack.map(function (module) {
+                    runFunction = onBuildStack(stack, dependencies);
+                    stackPromise = Promise.all(stack.map(function (pck) {
                         // p = p.then(() => {
-                        var command;
-                        //if we're skipping builds until a certain module
-                        if (!building) {
-                            //if the module name matches the module we're supposed to start from then start building modules
-                            if (module.moduleName == startFrom || module.packageName == startFrom) {
-                                building = true;
-                            }
-                            //else still waiting for the module
-                            else {
-                                log(chalk.blue('skipping ' + module.moduleName));
-                                command = Promise.resolve(true);
-                            }
-                        }
-                        //unless told otherwise, build the module
-                        if (!command) {
-                            command = execp('cd ' +
-                                module.path +
-                                ' && yarn lincd build' +
-                                (target ? ' ' + target : '') +
-                                (target2 ? ' ' + target2 : ''));
-                            log(chalk.cyan('Building ' + module.moduleName));
-                        }
-                        return command["catch"](function (err) {
-                            var dependentModules = [];
-                            dependencies.forEach(function (dModuleDependencies, dModule) {
-                                if (dModuleDependencies.indexOf(module) !== -1) {
-                                    dependentModules.push(dModule);
-                                }
-                            });
-                            if (dependentModules.length > 0) {
-                                failedModules.push(module.moduleName);
-                                printBuildResults(failedModules, done);
-                                console.log(chalk.magenta('Stopping build process because an error occurred whilst building ' +
-                                    module.moduleName +
-                                    ', which ' +
-                                    dependentModules.length +
-                                    ' other modules depend on.')); //"+dependentModules.map(d => d.moduleName).join(", ")));
-                                console.log(chalk.cyanBright('tip ') +
-                                    'Run ' +
-                                    chalk.green("lincd build-all from ".concat(module.moduleName)) +
-                                    ' to build only the remaining modules'); //"+dependentModules.map(d => d.moduleName).join(", ")));
-                                process.exit(1);
-                            }
-                            else {
-                                failedModules.push(module.moduleName);
-                            }
+                        return runFunction(pck)["catch"](function (_a) {
+                            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                            warn('Uncaught exception whilst running parallel function on ' + pck.moduleName, error.message);
+                            // warn(chalk.red(pck.moduleName+' failed:'));
+                            // console.log(stdout);
                         })
                             .then(function (res) {
-                            // console.log("RESULT: ",res);
-                            // if(res && res.includes("Aborted due to warnings"))
-                            // {
-                            //   failedModules.push(module.moduleName);
-                            // }
-                            // else
-                            // {
-                            done.add(module);
-                            // }
-                            modulesLeft--;
-                            log(chalk.magenta(modulesLeft + ' modules left'));
-                            if (modulesLeft == 0) {
-                                printBuildResults(failedModules, done);
-                            }
+                            done.add(pck);
                             return res;
                         });
-                        // });
-                        // done.add(module);
                     }));
-                    //wait till stack is completed
                     return [4 /*yield*/, stackPromise];
                 case 1:
-                    //wait till stack is completed
-                    _a.sent();
-                    // await p;
+                    stackResults = _a.sent();
+                    results = results.concat(stackResults);
                     //clear stack for next round
                     stack = [];
-                    //find those modules who have all their dependencies already built and add them to the stack
-                    modules.forEach(function (module) {
-                        var deps = dependencies.get(module);
-                        //if the module is not done yet
+                    //find those packages who have all their dependencies already built and add them to the stack
+                    lincdPackages.forEach(function (pkg) {
+                        var deps = dependencies.get(pkg);
+                        //if the package is not done yet
                         //but every dependency is now done OR was not something we can build (some @dacore dependencies may not be local)
-                        if (!done.has(module) &&
+                        if (!done.has(pkg) &&
                             deps.every(function (dependency) {
-                                return typeof dependency !== 'string' && (done.has(dependency) || !modules.has(dependency.moduleName));
+                                return typeof dependency !== 'string' && (done.has(dependency) || !lincdPackages.has(dependency.moduleName));
                             })) {
-                            stack.push(module);
+                            stack.push(pkg);
                         }
-                        // else if(!done.has(module))
+                        // else if(!done.has(package))
                         // {
-                        // 	console.log(chalk.red(module+' not yet'))
+                        // 	console.log(chalk.red(package+' not yet'))
                         // 	console.log('UNMET DEPS: '+deps.filter(dependency => !done.has(dependency)).join(" "))
                         // }
                     });
                     //if more to be built, iterate
                     if (stack.length > 0) {
-                        return [2 /*return*/, runStack()];
+                        return [2 /*return*/, runStack(stack)];
                     }
                     else {
-                        //if no more modules to build but we never started building...
-                        if (!building) {
-                            console.log(chalk.red('Could not find the module to start from. Please provide a correct package name or module name to build from'));
-                        }
-                        else {
-                            first_1 = true;
-                            modules.forEach(function (module) {
-                                if (!done.has(module)) {
-                                    var deps = dependencies.get(module);
-                                    if (first_1) {
-                                        console.log(chalk.red('CYCLICAL DEPENDENCIES? - could not build some modules because they depend on each other.'));
-                                        first_1 = false;
-                                    }
-                                    //print the cyclical dependencies
-                                    console.log(chalk.red(module.moduleName) +
-                                        ' depends on ' +
-                                        deps
-                                            .filter(function (dependency) {
-                                            return typeof dependency !== 'string';
-                                        })
-                                            .map(function (d) {
-                                            return done.has(d) ? d.moduleName : chalk.red(d.moduleName);
-                                        })
-                                            .join(', '));
-                                    //also print some information why these modules have not been moved into the stack
-                                    var stringDependencies = deps.filter(function (d) { return typeof d === 'string'; });
-                                    if (stringDependencies.length > 0) {
-                                        console.log(chalk.red('And it depends on these module(s) - which seem not to be proper modules :' +
-                                            stringDependencies.join(', ')));
-                                        console.log(chalk.red('Could you remove this from dependencies? Should it be a devDependency?'));
-                                    }
-                                }
-                            });
-                        }
+                        onStackEnd(results.filter(Boolean));
                     }
                     return [2 /*return*/];
             }
         });
     }); };
     //starts the process
-    runStack();
+    runStack(startStack);
+}
+function buildAll(target, target2) {
+    var _this = this;
+    console.log('Building all LINCD packages of this repository in order of dependencies');
+    var lincdPackages = getLocalLincdModuleMap();
+    var startFrom;
+    //by default start building
+    var building = true;
+    //option to start from a specific package in the stack
+    if (target == 'from') {
+        startFrom = target2;
+        //if we have a startFrom, then we havnt started the build process yet
+        building = startFrom ? false : true;
+        //clear targets
+        target = '';
+        target2 = '';
+        console.log(chalk.blue('Will skip builds until ' + startFrom));
+        return function (pkg) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); };
+    }
+    var done = new Set();
+    var failedModules = [];
+    progressUpdate(lincdPackages.size + ' packages left');
+    var modulesLeft = lincdPackages.size;
+    // let modulesLeft = lincdPackages.size - done.size;
+    runOnPackagesGroupedByDependencies(lincdPackages, function (packageGroup, dependencies) {
+        if (done.size > 0) {
+            debugInfo(chalk.magenta('\n-------\nThese packages are next, since all their dependencies have now been build:'));
+            // log(stack);
+        }
+        debugInfo('Now building: ' + chalk.blue(packageGroup.map(function (i) { return i.moduleName; })));
+        return function (pkg) { return __awaiter(_this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                //if we're skipping builds until a certain package
+                if (!building) {
+                    //if the package name matches the package we're supposed to start from then start building packages
+                    if (pkg.moduleName == startFrom || pkg.packageName == startFrom) {
+                        building = true;
+                    }
+                    //else still waiting for the package
+                    else {
+                        log(chalk.blue('skipping ' + pkg.moduleName));
+                        command = Promise.resolve(true);
+                    }
+                }
+                //unless told otherwise, build the package
+                if (!command) {
+                    command = execPromise('cd ' + pkg.path + ' && yarn lincd build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''), false, false, {}, false);
+                    debugInfo(chalk.cyan('Building ' + pkg.moduleName));
+                }
+                return [2 /*return*/, command["catch"](function (_a) {
+                        var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                        //this prints out the webpack output, including the build errors
+                        warn('Failed to build ' + pkg.moduleName);
+                        console.log(stdout);
+                        failedModules.push(pkg.moduleName);
+                        var dependentModules = getDependentPackages(dependencies, pkg);
+                        if (dependentModules.length > 0) {
+                            printBuildResults(failedModules, done);
+                            console.log(chalk.magenta('Stopping build process because an error occurred whilst building ' +
+                                pkg.moduleName +
+                                ', which ' +
+                                dependentModules.length +
+                                ' other packages depend on.')); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                            console.log(chalk.cyanBright('tip ') +
+                                'Run ' +
+                                chalk.green("lincd build-all from ".concat(pkg.moduleName)) +
+                                ' to build only the remaining packages'); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                            process.exit(1);
+                        }
+                    })
+                        .then(function (res) {
+                        done.add(pkg);
+                        modulesLeft--;
+                        // log(chalk.magenta(modulesLeft + ' packages left'));
+                        process.stdout.write(modulesLeft + ' packages left\r');
+                        if (modulesLeft == 0) {
+                            printBuildResults(failedModules, done);
+                        }
+                        return res;
+                    })];
+            });
+        }); };
+    }, function (dependencies) {
+        //if no more packages to build but we never started building...
+        if (!building) {
+            console.log(chalk.red('Could not find the package to start from. Please provide a correct package name or package name to build from'));
+        }
+        else {
+            //Detecting cyclical dependencies that caused some packages not to be build
+            var first_1 = true;
+            lincdPackages.forEach(function (pkg) {
+                if (!done.has(pkg)) {
+                    var deps = dependencies.get(pkg);
+                    if (first_1) {
+                        console.log(chalk.red('CYCLICAL DEPENDENCIES? - could not build some packages because they depend on each other.'));
+                        first_1 = false;
+                    }
+                    //print the cyclical dependencies
+                    console.log(chalk.red(pkg.moduleName) +
+                        ' depends on ' +
+                        deps
+                            .filter(function (dependency) {
+                            return typeof dependency !== 'string';
+                        })
+                            .map(function (d) {
+                            return done.has(d) ? d.moduleName : chalk.red(d.moduleName);
+                        })
+                            .join(', '));
+                    //also print some information why these packages have not been moved into the stack
+                    var stringDependencies = deps.filter(function (d) { return typeof d === 'string'; });
+                    if (stringDependencies.length > 0) {
+                        console.log(chalk.red('And it depends on these package(s) - which seem not to be proper packages :' +
+                            stringDependencies.join(', ')));
+                        console.log(chalk.red('Could you remove this from dependencies? Should it be a devDependency?'));
+                    }
+                }
+            });
+        }
+    });
+}
+function getDependentPackages(dependencies, pkg) {
+    var dependentModules = [];
+    dependencies.forEach(function (dModuleDependencies, dModule) {
+        if (dModuleDependencies.indexOf(pkg) !== -1) {
+            dependentModules.push(dModule);
+        }
+    });
+    return dependentModules;
 }
 /**
- * Returns a map of the modules that this repository manages (so no modules found through the workspaces who's path contains ../ )
+ * Returns a map of the packages that this repository manages (so no packages found through the workspaces who's path contains ../ )
  * @param rootPath
  */
 function getLocalLincdModuleMap(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
     var map = new Map();
-    getLincdModules(rootPath).forEach(function (module) {
-        if (module.path.indexOf('../') === -1 && module.path.indexOf('..\\') === -1) {
-            // console.log(module.path);
-            map.set(module.moduleName, module);
+    getLincdModules(rootPath).forEach(function (pkg) {
+        if (pkg.path.indexOf('../') === -1 && pkg.path.indexOf('..\\') === -1) {
+            // console.log(package.path);
+            map.set(pkg.moduleName, pkg);
         }
     });
     return map;
 }
 function getLocalLincdModules(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
-    return getLincdModules(rootPath).filter(function (module) {
-        return module.path.indexOf('..\\') === -1;
+    return getLincdModules(rootPath).filter(function (pkg) {
+        return pkg.path.indexOf('..\\') === -1;
     });
 }
 function getLincdModules(rootPath) {
@@ -558,16 +607,17 @@ function execp(cmd, log, allowError, options) {
         });
     });
 }
-function execPromise(command, log, allowError, options) {
+function execPromise(command, log, allowError, options, pipeOutput) {
     if (log === void 0) { log = false; }
     if (allowError === void 0) { allowError = false; }
+    if (pipeOutput === void 0) { pipeOutput = false; }
     return new Promise(function (resolve, reject) {
         if (log)
             console.log(chalk.cyan(command));
-        exec(command, options, function (error, stdout, stderr) {
+        var child = exec(command, options, function (error, stdout, stderr) {
             if (error) {
                 if (!allowError) {
-                    reject(error.message);
+                    reject({ error: error, stdout: stdout, stderr: stderr });
                     return;
                 }
                 else if (log) {
@@ -583,6 +633,10 @@ function execPromise(command, log, allowError, options) {
             }
             resolve(result);
         });
+        if (pipeOutput) {
+            child.stdout.pipe(process.stdout);
+            child.stderr.pipe(process.stderr);
+        }
     });
 }
 var replaceVariablesInFile = function (filePath) { return __awaiter(void 0, void 0, void 0, function () {
@@ -606,9 +660,7 @@ var replaceCurlyVariables = function (string) {
 };
 var capitalize = function (str) { return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1); };
 var camelCase = function (str) {
-    var string = str
-        .replace(/[^A-Za-z0-9]/g, ' ')
-        .split(' ');
+    var string = str.replace(/[^A-Za-z0-9]/g, ' ').split(' ');
     if (string.length > 1) {
         return string.reduce(function (result, word) { return result + capitalize(word); });
     }
@@ -806,7 +858,7 @@ var createModule = function (name, uriBase, basePath) {
             switch (_c.label) {
                 case 0:
                     //if ran with npx, basePath will be the root directory of the repository, even if we're executing from a sub folder (the root directory is where node_modules lives and package.json with workspaces)
-                    //so we manually find a modules folder, if it exists we go into that.
+                    //so we manually find a packages folder, if it exists we go into that.
                     if (fs.existsSync(path.join(basePath, 'modules'))) {
                         basePath = path.join(basePath, 'modules');
                     }
@@ -825,12 +877,12 @@ var createModule = function (name, uriBase, basePath) {
                     // --> match[0] = @dacore/some-mod
                     // --> match[1] = @dacore
                     // --> match[2] = some-mod
-                    //but save full scoped module name under ${module_name}
+                    //but save full scoped package name under ${module_name}
                     setVariable('module_name', name);
                     //extra variable for clarity (will be same as 'name')
                     setVariable('output_file_name', name);
                     _b = setNameVariables(cleanPackageName), hyphenName = _b.hyphenName, camelCaseName = _b.camelCaseName, underscoreName = _b.underscoreName;
-                    log("Creating new LINCD module '" + name + "'");
+                    log("Creating new LINCD package '" + name + "'");
                     fs.copySync(path.join(__dirname, '..', 'defaults', 'module'), targetFolder);
                     //replace variables in some of the copied files
                     return [4 /*yield*/, Promise.all([
@@ -849,7 +901,7 @@ var createModule = function (name, uriBase, basePath) {
                 case 1:
                     //replace variables in some of the copied files
                     _c.sent();
-                    //rename these to a file name similar to the module name
+                    //rename these to a file name similar to the pkg name
                     [
                         'src/ontologies/example-ontology.ts',
                         'src/data/example-ontology.json',
@@ -874,7 +926,7 @@ var createModule = function (name, uriBase, basePath) {
                         })];
                 case 3:
                     _c.sent();
-                    log("Prepared a new LINCD module in ".concat(chalk.magenta(targetFolder)), "Run ".concat(chalk.blueBright('yarn build'), " from this directory to build once"), "Or ".concat(chalk.blueBright('yarn dev'), " to continuously rebuild on file changes"));
+                    log("Prepared a new LINCD package in ".concat(chalk.magenta(targetFolder)), "Run ".concat(chalk.blueBright('yarn build'), " from this directory to build once"), "Or ".concat(chalk.blueBright('yarn dev'), " to continuously rebuild on file changes"));
                     return [2 /*return*/];
             }
         });
@@ -961,7 +1013,7 @@ var buildFailed = function (output) {
         }
         else
         {
-            console.warn("Invalid LINCD module. Index file should export a packageExports object. See examples.")
+            console.warn("Invalid LINCD package. Index file should export a packageExports object. See examples.")
         }
 
     } else {
@@ -1050,7 +1102,7 @@ var buildModule = function (target, target2, modulePath, logResults) {
     }
 };
 var getLastBuildTime = function (modulePath) {
-    return getLastModifiedFile(modulePath + '/@(builds|lib)/**/*.js');
+    return getLastModifiedFile(modulePath + '/@(builds|lib|dist)/**/*.js');
 };
 var getLastModifiedSourceTime = function (modulePath) {
     return getLastModifiedFile(modulePath + '/@(src|data|scss)/**/*', {
@@ -1060,10 +1112,15 @@ var getLastModifiedSourceTime = function (modulePath) {
 var getLastCommitTime = function (modulePath) {
     // console.log(`git log -1 --format=%ci -- ${modulePath}`);
     // process.exit();
-    return execPromise("git log -1 --format=%ci -- ".concat(modulePath)).then(function (result) {
+    return execPromise("git log -1 --format=%ci -- ".concat(modulePath))
+        .then(function (result) {
         var lastCommit = new Date(result);
         // console.log(modulePath,result,lastCommit);
         return lastCommit;
+    })["catch"](function (_a) {
+        var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+        debugInfo(chalk.red('Git error: ') + error.message.toString());
+        return null;
     });
 };
 var getLastModifiedFile = function (filePath, config) {
@@ -1092,60 +1149,90 @@ var getLastModifiedFile = function (filePath, config) {
 var publishUpdated = function (test) {
     var _this = this;
     if (test === void 0) { test = false; }
-    var modules = getLocalLincdModules();
+    var packages = getLocalLincdModules();
     var browserCoreBuilt = false;
     var p = Promise.resolve('');
-    modules.forEach(function (module) {
+    var packagesLeft = packages.length;
+    console.log('Checking which packages need to be published by comparing last published date with last git commit');
+    packages.forEach(function (pckg) {
         p = p.then(function (previousResult) {
-            log('# Checking module ' + module.moduleName);
-            // log('# Requesting ' + 'yarn info '+module.packageName+' --json');
-            // return execPromise('yarn info '+module.packageName+' --json').then((output:string) => {
+            progressUpdate(packagesLeft-- + ' packages left. Now checking ' + pckg.moduleName);
+            debugInfo('# Checking package ' + pckg.moduleName);
+            // log('# Requesting ' + 'yarn info '+pkg.packageName+' --json');
+            // return execPromise('yarn info '+pkg.packageName+' --json').then((output:string) => {
             // console.log("Will be requesting npm view from this current working directory:\n"+process.cwd());
-            // return execPromise('npm view '+module.packageName+' --json').then((output:string) => {
-            return execPromise('yarn info ' + module.packageName + ' --json')
+            // return execPromise('npm view '+pkg.packageName+' --json').then((output:string) => {
+            var shouldPublish;
+            var pack = (0, utils_1.getPackageJSON)(pckg.path);
+            var version = getNextVersion(pack.version);
+            if (pack.private) {
+                shouldPublish = false;
+                debugInfo(chalk.blue('--> is private, skipping'));
+                return previousResult + ' ' + chalk.gray(pckg.moduleName + ' is private\n');
+            }
+            return execPromise('yarn info ' + pckg.packageName + ' --json')
                 .then(function (output) { return __awaiter(_this, void 0, void 0, function () {
-                var info, lastPublish, lastPublishDate, _a, lastModifiedTime, lastModifiedName, lastModified, lastCommit, res, browserModule;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                var info, lastPublish, lastPublishDate, lastCommit, res, browserModule;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
                         case 0:
                             try {
                                 if (output == '') {
-                                    // console.warn("No response (empty) from `yarn info`");
-                                    throw new Error('Empty response from `npm view`');
-                                    return [2 /*return*/];
+                                    debugInfo('No response (empty) from `yarn info`. This package was probably not published before');
+                                    // throw new Error('Empty response from `yarn info`. This pkg was probably not published before');
+                                    // return;
+                                    shouldPublish = true;
+                                    //don't patch the version number (default, see above), use the current version
+                                    version = pack.version;
+                                }
+                                else {
+                                    info = JSON.parse(output);
                                 }
-                                info = JSON.parse(output);
                                 // var stats = fs.statSync(path.join(moduleDirectory));
                                 // var files = fs.readdirSync(path.join(moduleDirectory,'src'));
                             }
                             catch (err) {
-                                chalk.red(module.moduleName + ' failed: ' + err.message + '\n');
+                                chalk.red(pckg.moduleName + ' failed: ' + err.message + '\n');
                                 console.warn('Returned JSON from npm: ' + output);
-                                return [2 /*return*/, previousResult + ' ' + chalk.red(module.moduleName + ' failed: ' + err.message + '\n')];
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.moduleName + ' failed: ' + err.message + '\n')];
                             }
+                            if (!info) return [3 /*break*/, 2];
                             lastPublish = info.data.time[info.data.version];
                             lastPublishDate = new Date(lastPublish);
-                            _a = getLastModifiedSourceTime(module.path), lastModifiedTime = _a.lastModifiedTime, lastModifiedName = _a.lastModifiedName, lastModified = _a.lastModified;
-                            return [4 /*yield*/, getLastCommitTime(module.path)];
+                            return [4 /*yield*/, getLastCommitTime(pckg.path)];
                         case 1:
-                            lastCommit = _b.sent();
-                            console.log(lastPublishDate.toDateString() + ' ' + lastPublishDate.toTimeString() + ' published ' + info.data.version);
-                            console.log(lastCommit.toDateString() + ' ' + new Date(lastCommit).toTimeString() + ' source last committed');
-                            // console.log(lastModified.toDateString() + ' ' + new Date(lastModified).toTimeString() + ' source ' + lastModifiedName + ' last edited');
-                            //NOTE: removed lastModified, because switching branches will say that the file was modified and cause everything to publish
-                            //SO: now you NEED TO commit before it picks up that you should publish
-                            //|| lastPublishDate.getTime() < lastModified.getTime()
-                            if (lastPublishDate.getTime() < lastCommit.getTime()) {
-                                res = executeSingleBuild(module, previousResult, test, info);
-                                if (module.moduleName == 'browser-core') {
+                            lastCommit = _a.sent();
+                            if (!lastCommit) {
+                                shouldPublish = false;
+                                debugInfo('Could not determine last git commit');
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.moduleName + ' - could not determine last commit\n')];
+                            }
+                            else {
+                                //NOTE: removed lastModified, because switching branches will say that the file was modified and cause everything to publish
+                                //SO: now you NEED TO commit before it picks up that you should publish
+                                shouldPublish = lastPublishDate.getTime() < lastCommit.getTime();
+                                if (shouldPublish) {
+                                    debugInfo(lastPublishDate.toDateString() +
+                                        ' ' +
+                                        lastPublishDate.toTimeString() +
+                                        ' published ' +
+                                        info.data.version);
+                                    debugInfo(lastCommit.toDateString() + ' ' + new Date(lastCommit).toTimeString() + ' source last committed');
+                                }
+                            }
+                            _a.label = 2;
+                        case 2:
+                            if (shouldPublish) {
+                                res = publishPackage(pckg, previousResult, test, info, version);
+                                if (pckg.moduleName == 'browser-core') {
                                     browserCoreBuilt = true;
                                 }
                                 //when publishing core, also make sure to publish browser-core
-                                if (module.moduleName == 'core' && !browserCoreBuilt) {
-                                    browserModule = modules.find(function (m) { return m.moduleName == 'browser-core'; });
+                                if (pckg.moduleName == 'core' && !browserCoreBuilt) {
+                                    browserModule = packages.find(function (m) { return m.moduleName == 'browser-core'; });
                                     return [2 /*return*/, Promise.resolve(res).then(function (previousResult) {
-                                            log('# Automatically also publishing module browser-core');
-                                            return executeSingleBuild(browserModule, previousResult, test);
+                                            log('# Automatically also publishing package browser-core');
+                                            return publishPackage(browserModule, previousResult, test);
                                         })];
                                 }
                                 return [2 /*return*/, res];
@@ -1153,142 +1240,194 @@ var publishUpdated = function (test) {
                             return [2 /*return*/, previousResult];
                     }
                 });
-            }); })["catch"](function (err) {
-                console.log(err);
-                return previousResult + ' ' + chalk.red(module.moduleName + ' failed\n');
+            }); })["catch"](function (_a) {
+                var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                console.log(error.message);
+                return previousResult + ' ' + chalk.red(pckg.moduleName + ' failed\n');
             });
         });
     });
     return p.then(function (messages) {
         if (messages == '') {
-            console.log('All published modules are already up-to-date.');
+            console.log('All published packages are already up-to-date.');
         }
         else {
             console.log('Summary: \n' + messages);
         }
     });
 };
-var executeSingleBuild = function (module, previousResult, test, info) {
-    var nextVersion = info ? getNextVersion(info.data.version) : '';
-    console.log(chalk.blue('--> ' + (test ? 'should publish' : 'publishing') + ' ' + module.moduleName + ' ' + nextVersion));
+var publishPackage = function (pkg, previousResult, test, info, publishVersion) {
+    if (!publishVersion) {
+        publishVersion = info ? getNextVersion(info.data.version) : '';
+    }
+    if (test) {
+        debugInfo('should publish ' + pkg.moduleName + ' ' + publishVersion);
+    }
+    else {
+        console.log(chalk.blue('publishing ' + pkg.moduleName + ' ' + publishVersion));
+    }
     if (!test) {
-        return execPromise('cd ' + module.path + ' && yarn lincd register', true)
+        return execPromise("cd ".concat(pkg.path, " && yarn publish").concat(publishVersion ? ' --new-version ' + publishVersion : ''), true, false, {}, true)
             .then(function (res) {
             if (res.indexOf('Aborted due to warnings') !== -1 ||
                 res.indexOf('Could not publish') !== -1 ||
                 res.indexOf("Couldn't publish") !== -1) {
                 console.log(res);
-                return previousResult + ' ' + chalk.red(module.moduleName + ' failed\n');
+                return previousResult + ' ' + chalk.red(pkg.moduleName + ' failed\n');
             }
-            console.log(chalk.green('Successfully published ' + nextVersion));
-            return previousResult + ' ' + chalk.green(module.moduleName + ' published ' + nextVersion + '\n');
-        })["catch"](function (err) {
-            console.log(chalk.red('Failed to publish: ' + err));
-            return chalk.red('Failed to publish: ' + err);
+            console.log(chalk.green('Successfully published ' + pkg.path + ' ' + publishVersion));
+            return previousResult + ' ' + chalk.green(pkg.moduleName + ' published ' + publishVersion + '\n');
+        })["catch"](function (_a) {
+            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+            console.log(chalk.red('Failed to publish: ' + error.message));
+            return previousResult + ' ' + chalk.red(pkg.moduleName + ' failed to publish\n');
         });
     }
     else {
         //when testing what needs to be published
-        return previousResult + ' ' + chalk.blue(module.moduleName + ' should publish\n');
+        return previousResult + ' ' + chalk.blue(pkg.moduleName + ' should publish\n');
     }
 };
 var buildUpdated = function (back, target, target2, test) {
     if (test === void 0) { test = false; }
-    // back = back || 1;
-    // return execPromise(`git log -${back} --format=%ci`).then((result) => {
-    // let now = new Date();
-    var previousResult = '';
-    log((test ? 'Checking which modules' : 'Building all modules that') + ' have been changed since their last built ');
-    var modules = getLocalLincdModules();
-    //TODO: sort all these modules in the order of their dependencies.
-    // To do so, see build-all command and put some of the functionality (like getting modules that depend on a module) in reusable functions
-    var p = Promise.resolve('');
-    modules.forEach(function (module) {
-        var moduleName = module.moduleName;
-        p = p
-            .then(function (previousResult) {
-            var lastModifiedSource = getLastModifiedSourceTime(module.path);
-            var lastModifiedBundle = getLastBuildTime(module.path);
-            // console.log(module.path,lastModifiedSource.lastModifiedTime,lastModifiedBundle.lastModifiedTime);
-            // console.log(module.path,new Date(lastModifiedSource.lastModified).toString(),new Date(lastModifiedBundle.lastModified).toString());
-            console.log('# Checking module ' + moduleName);
-            if (lastModifiedSource.lastModifiedTime > lastModifiedBundle.lastModifiedTime) {
-                //TODO: when building a module, also rebuild all modules that depend on this module.. and iteratively build modules that depend on those modules..
-                // log(moduleName+' modified since last commit on '+now.toString());
-                console.log(chalk.cyan('Last modified source: ' +
-                    lastModifiedSource.lastModifiedName +
-                    ' on ' +
-                    lastModifiedSource.lastModified.toString()));
-                console.log(chalk.cyan('Last build: ' +
-                    (lastModifiedBundle && typeof lastModifiedBundle.lastModified !== 'undefined'
-                        ? lastModifiedBundle.lastModified.toString()
-                        : 'never')));
-                log('--> ' + (test ? 'need to build ' : 'building ') + moduleName);
-                if (!test) {
-                    return execPromise('cd ' + module.path + ' && yarn build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : '')).then(function (res) {
-                        if (res.indexOf('Aborted due to warnings') !== -1 || res.indexOf('Fatal error') !== -1) {
-                            console.log(res);
-                            return previousResult + ' ' + chalk.red(moduleName + ' failed\n');
+    return __awaiter(this, void 0, void 0, function () {
+        var previousResult, packages, jsonldPkgUpdated, cliPkgUpdated, rebuildAllModules, packagesLeft, p;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    previousResult = '';
+                    log(test ? 'Checking which packages need to be rebuild' : 'Building updated packages');
+                    packages = getLocalLincdModuleMap();
+                    jsonldPkgUpdated = needsRebuilding(packages.get('lincd-jsonld'));
+                    cliPkgUpdated = needsRebuilding(packages.get('lincd-cli'));
+                    if (!(jsonldPkgUpdated || cliPkgUpdated)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, execPromise('yarn build-core', false, false, {}, true)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    rebuildAllModules = false;
+                    if (cliPkgUpdated) {
+                        rebuildAllModules = true;
+                        log(chalk.magenta('Rebuilding all modules because the build tools (lincd-cli) got updated'));
+                    }
+                    packagesLeft = packages.size;
+                    runOnPackagesGroupedByDependencies(packages, function (packageGroup, dependencies) {
+                        // console.log('Now checking: ' + chalk.blue(packageGroup.map((i) => i.moduleName)));
+                        // console.log((packagesLeft) + " packages left.");
+                        packagesLeft = packagesLeft - packageGroup.length;
+                        return function (pkg) { return __awaiter(_this, void 0, void 0, function () {
+                            var needRebuild;
+                            return __generator(this, function (_a) {
+                                debugInfo('# Checking package ' + pkg.moduleName);
+                                needRebuild = needsRebuilding(pkg, true);
+                                if (pkg.moduleName === 'lincd-jsonld' && jsonldPkgUpdated) {
+                                    needRebuild = true;
+                                }
+                                // console.log(pkg.path,lastModifiedSource.lastModifiedTime,lastModifiedBundle.lastModifiedTime);
+                                // console.log(pkg.path,new Date(lastModifiedSource.lastModified).toString(),new Date(lastModifiedBundle.lastModified).toString());
+                                if (needRebuild || rebuildAllModules) {
+                                    //TODO: when building a pkg, also rebuild all packages that depend on this package.. and iteratively build packages that depend on those packages..
+                                    // log(moduleName+' modified since last commit on '+now.toString());
+                                    if (test) {
+                                        debugInfo('Need to build ' + pkg.moduleName);
+                                        return [2 /*return*/, chalk.blue(pkg.moduleName + ' should be build')];
+                                    }
+                                    log('Building ' + pkg.moduleName);
+                                    return [2 /*return*/, execPromise('cd ' + pkg.path + ' && yarn build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''))
+                                            .then(function (res) {
+                                            debugInfo(chalk.green(pkg.moduleName + ' successfully built'));
+                                            return chalk.green(pkg.moduleName + ' built');
+                                        })["catch"](function (_a) {
+                                            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                                            warn('Failed to build ' + pkg.moduleName);
+                                            console.log(stdout);
+                                            var dependentModules = getDependentPackages(dependencies, pkg);
+                                            if (dependentModules.length > 0) {
+                                                // printBuildResults(failedModules, done);
+                                                warn(chalk.red(pkg.moduleName + ' build failed'));
+                                                warn('Stopping build-updated process because ' +
+                                                    dependentModules.length +
+                                                    ' other packages depend on this module.\n'); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                                                process.exit(1);
+                                            }
+                                        })];
+                                }
+                                return [2 /*return*/];
+                            });
+                        }); };
+                    }, function (results) {
+                        if (results.length) {
+                            log('Summary:');
+                            log(results.join('\n'));
+                        }
+                        else {
+                            log(chalk.green('Nothing to rebuild'));
                         }
-                        console.log(chalk.green(moduleName + ' bundles successfully built'));
-                        return previousResult + ' ' + chalk.green(moduleName + ' built\n');
                     });
-                }
-                return previousResult + ' ' + chalk.blue(moduleName + ' should be build\n');
+                    return [2 /*return*/];
             }
-            return previousResult;
-        })["catch"](function (err) {
-            console.log(err);
-            return previousResult + ' ' + chalk.red(moduleName + ' failed\n');
         });
     });
-    return p.then(function (messages) {
-        if (messages == '') {
-            console.log(chalk.green('Nothing to rebuild.'));
-        }
-        else {
-            console.log('Summary: \n' + messages);
-        }
-    });
-    // });
+};
+var needsRebuilding = function (pkg, logDetailsIfTrue) {
+    if (logDetailsIfTrue === void 0) { logDetailsIfTrue = false; }
+    var lastModifiedSource = getLastModifiedSourceTime(pkg.path);
+    var lastModifiedBundle = getLastBuildTime(pkg.path);
+    var result = lastModifiedSource.lastModifiedTime > lastModifiedBundle.lastModifiedTime;
+    if (logDetailsIfTrue) {
+        debugInfo(chalk.cyan('Last modified source: ' +
+            lastModifiedSource.lastModifiedName +
+            ' on ' +
+            lastModifiedSource.lastModified.toString()));
+        debugInfo(chalk.cyan('Last build: ' +
+            (lastModifiedBundle && typeof lastModifiedBundle.lastModified !== 'undefined'
+                ? lastModifiedBundle.lastModified.toString()
+                : 'never')));
+    }
+    return result;
 };
 var printBuildResults = function (failed, done) {
-    log('Build results: ' +
-        chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.moduleName; }).join(', ')) +
-        (failed.length > 0 ? ', ' + chalk.red(failed.join(', ')) : '') +
-        '\n');
+    log('Successfully built: ' + chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.moduleName; }).join(', ')) + '\n');
+    if (failed.length > 0) {
+        warn('Failed to build: ' + chalk.red(failed.join(', ')) + '\n');
+    }
 };
-var executeCommandForEachModule = function (modules, command, filterMethod, filterValue) {
-    //if a specific set of modules is given
+var executeCommandForEachModule = function (packages, command, filterMethod, filterValue) {
+    //if a specific set of packages is given
     if (filterMethod == 'exclude') {
-        //filter modules, so that we only execute on the modules as provided in the command
+        //filter packages, so that we only execute on the packages as provided in the command
         log('Excluding ' + filterValue);
         filterValue = filterValue.split(',');
-        modules = modules.filter(function (module) { return filterValue.indexOf(module.moduleName) === -1; });
+        packages = packages.filter(function (pkg) { return filterValue.indexOf(pkg.moduleName) === -1; });
     }
     var startFrom;
     //by default start executing, unless 'from' is given
     var executing = true;
-    //option to start from a specific module in the stack
+    //option to start from a specific pkg in the stack
     if (filterMethod == 'from') {
         startFrom = filterValue;
         if (startFrom) {
             console.log(chalk.blue('Will skip ahead to ' + startFrom));
         }
         var seen_1 = false;
-        modules = modules.filter(function (module) {
-            if (!seen_1 && (module.moduleName == startFrom || module.packageName == startFrom)) {
+        packages = packages.filter(function (pkg) {
+            if (!seen_1 && (pkg.moduleName == startFrom || pkg.packageName == startFrom)) {
                 seen_1 = true;
             }
             return seen_1;
         });
     }
-    log("Executing '" + chalk.blueBright(command) + "' on modules " + chalk.magenta(modules.map(function (m) { return m.moduleName; }).join(', ')));
+    log("Executing '" +
+        chalk.blueBright(command) +
+        "' on packages " +
+        chalk.magenta(packages.map(function (m) { return m.moduleName; }).join(', ')));
     var p = Promise.resolve(true);
-    modules.forEach(function (module) {
+    packages.forEach(function (pkg) {
         p = p.then(function () {
-            log('# Package ' + chalk.magenta(module.moduleName));
-            return execp('cd ' + module.path + ' && ' + command);
+            log('# Package ' + chalk.magenta(pkg.moduleName));
+            return execp('cd ' + pkg.path + ' && ' + command);
         });
     });
     return p;
@@ -1302,7 +1441,7 @@ var executeCommandForModule = function (moduleName, command) {
         return execp('cd ' + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
     }
     else {
-        warn("Could not find a module who's name (partially) matched " + chalk.cyan(moduleName));
+        warn("Could not find a pkg who's name (partially) matched " + chalk.cyan(moduleName));
     }
 };
 program.parse(process.argv);

package/lib/config-webpack.js

@@ -32,7 +32,7 @@ var path = require('path');
 var BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 var TerserPlugin = require('terser-webpack-plugin');
 var exec = require('child_process').exec;
-var CopyPlugin = require("copy-webpack-plugin");
+var CopyPlugin = require('copy-webpack-plugin');
 var NODE_ENV = process.env.NODE_ENV;
 var nodeProduction = NODE_ENV == 'production';
 // const libraryName = 'lincd';
@@ -83,7 +83,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
         new CopyPlugin({
             patterns: [
                 {
-                    from: "src/**/*.scss",
+                    from: 'src/**/*.scss',
                     to: function (_a) {
                         var context = _a.context, absoluteFilename = _a.absoluteFilename;
                         // console.log(chalk.magenta(context),chalk.magenta(absoluteFilename),process.cwd());
@@ -165,6 +165,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
                                 // "postcss-scss": {}, //<-- only add this back if the build gets stuck on //comments in scss files, but I dont think that will be the case anymore
                                 'postcss-modules': {
                                     //   //by default postcss-modules will put out a json file right next to the original css / scss file, this method defines what classnames to use
+                                    //   generateScopedName:generateScopedName.bind(null,moduleName),
                                     generateScopedName: utils_1.generateScopedName.bind(null, moduleName),
                                     globalModulePaths: [/tailwind/]
                                 },
@@ -327,7 +328,7 @@ function generateWebpackConfig(buildName, moduleName, config) {
         //stats:{chunks:!watch,version:!watch}//hide some info from output when in watch mode to keep it succinct
         cache: {
             // https://webpack.js.org/configuration/other-options/#cache
-            type: "filesystem"
+            type: 'filesystem'
         }
     };
 }

package/lib/utils.js

@@ -51,11 +51,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-exports.flatten = exports.warn = exports.debug = exports.log = exports.generateScopedName = exports.getPackageJSON = void 0;
+exports.flatten = exports.warn = exports.debug = exports.log = exports.generateScopedName = exports.getGruntConfig = exports.getPackageJSON = void 0;
 var fs = __importStar(require("fs"));
 var path = __importStar(require("path"));
 var chalk_1 = __importDefault(require("chalk"));
-// const {findNearestPackageJson, findNearestPackageJsonSync} = require('find-nearest-package-json');
+var _a = require('find-nearest-package-json'), findNearestPackageJson = _a.findNearestPackageJson, findNearestPackageJsonSync = _a.findNearestPackageJsonSync;
 var getPackageJSON = function (root, error) {
     if (root === void 0) { root = process.cwd(); }
     if (error === void 0) { error = true; }
@@ -71,6 +71,21 @@ var getPackageJSON = function (root, error) {
     }
 };
 exports.getPackageJSON = getPackageJSON;
+var getGruntConfig = function (root, error) {
+    if (root === void 0) { root = process.cwd(); }
+    if (error === void 0) { error = true; }
+    var gruntFile = path.join(root, 'Gruntfile.js');
+    if (fs.existsSync(gruntFile)) {
+        return require(gruntFile)();
+    }
+    else if (root === process.cwd()) {
+        if (error) {
+            console.warn('Could not find Gruntfile.js. Make sure you run this command from the root of a lincd module or a lincd yarn workspace');
+            process.exit();
+        }
+    }
+};
+exports.getGruntConfig = getGruntConfig;
 /*export function getShapesJSONLD(packageExports): Promise<string> {
   // return JSONLDWriter.stringify(getShapes(packageExports));
 }
@@ -89,14 +104,15 @@ export function getShapes(packageExports): CoreSet<SHACL_Shape> {
   }
   return shapes;
 }*/
+// export function generateScopedName(moduleName,name, filename, css) {
 function generateScopedName(moduleName, name, filename, css) {
     // console.log(moduleName,name,filename,css);
-    // var file = path.basename(filename, '.scss');
-    // let nearestPackageJson = findNearestPackageJsonSync(filename);
-    // let packageName = nearestPackageJson ? nearestPackageJson.data.name : packageJson.name;
-    // return packageName.replace(/[^a-zA-Z0-9_]+/g, '_') + '_' + file + '_' + name;
+    var file = path.basename(filename, '.scss');
+    var nearestPackageJson = findNearestPackageJsonSync(filename);
+    var packageName = nearestPackageJson ? nearestPackageJson.data.name : moduleName;
+    return packageName.replace(/[^a-zA-Z0-9_]+/g, '_') + '_' + file + '_' + name;
     // process.exit();
-    var path = require('path');
+    // var path = require('path');
     var file = path.basename(filename, '.scss');
     var module = filename.match(/[\\\/]modules[\\\/]([\w\-_]+)/);
     var moduleName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lincd-cli",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Command line tools for the lincd.js library",
   "main": "lib/index.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "build": "npm exec tsc",
     "dev": "npm exec tsc -w"
   },
-  "lincd_util": true,
+  "lincd": true,
   "keywords": [
     "lincd",
     "cli",
@@ -43,6 +43,7 @@
     "commander": "^9.4.0",
     "copy-webpack-plugin": "^11.0.0",
     "css-loader": "^6.7.1",
+    "find-nearest-package-json": "^2.0.1",
     "fs-extra": "^10.1.0",
     "glob": "^7.1.6",
     "grunt": "^1.3.0",