lincd-cli 0.1.24 → 0.2.1

package/defaults/app/package.json

@@ -22,9 +22,9 @@
     "web3"
   ],
   "dependencies": {
-    "lincd": "^0.3.6"
+    "lincd": "^0.4"
   },
   "devDependencies": {
-    "lincd-cli": "^0.1"
+    "lincd-cli": "^0.2"
   }
 }

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

@@ -0,0 +1,4 @@
+node_modules
+frontend/build
+modules/**/dist
+modules/**/lib

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

@@ -37,7 +37,7 @@
     "@babel/preset-react": "^7.18.6",
     "@babel/preset-typescript": "^7.18.6",
     "@babel/register": "^7.18.9",
-    "lincd": "^0.3.6",
+    "lincd": "^0.4",
     "lincd-jsonld": "^0.1.5",
     "lincd-server": "^0.1",
     "react": "^18.2",
@@ -49,8 +49,7 @@
     "@types/react": "^18.0.17",
     "@types/react-dom": "^18.0.6",
     "env-cmd": "^10.1.0",
-    "lincd-cli": "^0.1",
-    "nodemon": "^2.0.6",
-    "ts-loader": "^9.4.1"
+    "lincd-cli": "^0.2",
+    "nodemon": "^2.0.6"
   }
 }

package/defaults/{module → package}/Gruntfile.js

@@ -1,5 +1,5 @@
 var buildTools = require('lincd-cli');
-module.exports = buildTools.generateGruntConfig('${module_name}', {
+module.exports = buildTools.generateGruntConfig('${package_name}', {
 	externals: {
 		react: 'React',
 		'react-dom': 'ReactDOM',

package/defaults/{module → package}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "${module_name}",
+  "name": "${package_name}",
   "description": "",
   "author": {
     "name": "",
@@ -29,10 +29,10 @@
     "web3"
   ],
   "dependencies": {
-    "lincd": "^0.3.6",
+    "lincd": "^0.4",
     "lincd-jsonld": "^0.1"
   },
   "devDependencies": {
-    "lincd-cli": "^0.1"
+    "lincd-cli": "^0.2"
   }
 }

package/defaults/{module → package}/src/package.ts

@@ -1,4 +1,4 @@
 import {linkedPackage} from 'lincd/lib/utils/Module';
 
 export const {linkedComponent, linkedComponentClass, linkedShape, linkedUtil, linkedOntology, registerPackageModule, registerPackageExport, packageExports} =
-  linkedPackage('${module_name}');
+  linkedPackage('${package_name}');

package/lib/cli.js

@@ -81,9 +81,9 @@ program
     .description('Creates a new folder with all the required files for a LINCD app')
     .argument('<name>', 'the name of your LINCD app. To use spaces, wrap the name in double quotes.');
 program
-    .command('create-module')
+    .command('create-package')
     .action(function (name, uriBase) {
-    return createModule(name, uriBase);
+    return createPackage(name, uriBase);
 })
     .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')
@@ -131,7 +131,7 @@ program
 })
     .description("Log the version of this tool and the path that it's running from");
 program.command('build [target] [target2]', { isDefault: true }).action(function (target, target2) {
-    buildModule(target, target2);
+    buildPackage(target, target2);
 });
 program.command('publish-updated').action(function () {
     return publishUpdated();
@@ -153,16 +153,16 @@ program.command('build-all [target] [target2]').action(function (target, target2
     buildAll(target, target2);
 });
 program.command('all [action] [filter] [filter-value]').action(function (command, filter, filterValue) {
-    executeCommandForEachModule(getLincdModules(), command, filter, filterValue);
+    executeCommandForEachPackage(getLincdPackages(), command, filter, filterValue);
 });
 // 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);
+    developPackage(target, mode);
 });
 program
-    .command('module|m|package|p')
+    .command('package')
     .action(function (name, command, args) {
     var fullCommand = command
         ? command +
@@ -173,9 +173,12 @@ program
                 .filter(function (a) { return a && true; })
                 .join(' ')
         : null;
-    executeCommandForModule(name, fullCommand);
+    executeCommandForPackage(name, fullCommand);
 })
+    .alias('p')
+    .alias('pkg')
     .alias('m')
+    .alias('module')
     .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')
@@ -229,7 +232,7 @@ function warn() {
         // console.log(chalk.red(message));
     });
 }
-function developModule(target, mode) {
+function developPackage(target, mode) {
     if (!target)
         target = 'es6';
     if (mode !== 'production')
@@ -261,29 +264,28 @@ function checkWorkspaces(rootPath, workspaces, res) {
                 var folders = fs.readdirSync(workspacePath);
                 folders.forEach(function (folder) {
                     if (folder !== './' && folder !== '../') {
-                        checkModulePath(rootPath, path.join(workspacePath, folder), res);
+                        checkPackagePath(rootPath, path.join(workspacePath, folder), res);
                     }
                 });
             }
         }
         else {
-            checkModulePath(rootPath, workspacePath, res);
+            checkPackagePath(rootPath, workspacePath, res);
         }
     });
 }
-function checkModulePath(rootPath, modulePath, res) {
-    var packagePath = path.join(modulePath, 'package.json');
+function checkPackagePath(rootPath, packagePath, res) {
+    var packageJsonPath = path.join(packagePath, 'package.json');
     // console.log('checking '+packagePath);
-    if (fs.existsSync(packagePath)) {
-        var pack = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    if (fs.existsSync(packageJsonPath)) {
+        var pack = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
         //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);
+            checkWorkspaces(packagePath, pack.workspaces, res);
         }
         else if (pack && pack.lincd === true) {
             res.push({
-                path: modulePath,
-                moduleName: pack.name,
+                path: packagePath,
                 packageName: pack.name
             });
         }
@@ -293,28 +295,28 @@ function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStack
     var _this = this;
     var dependencies = new Map();
     //get dependencies of each package
-    var leastDependentModule;
+    var leastDependentPackage;
     lincdPackages.forEach(function (pkg) {
         var pack = (0, utils_1.getPackageJSON)(pkg.path);
         if (pack) {
             //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)
+            var packageDependencies = Object.keys(pack.dependencies)
                 .filter(function (dependency) { return lincdPackages.has(dependency); })
                 .map(function (dependency) {
                 return lincdPackages.has(dependency) ? lincdPackages.get(dependency) : dependency;
             });
-            // console.log(package.moduleName,moduleDependencies.map())
-            dependencies.set(pkg, moduleDependencies);
+            // console.log(package.packageName,packageDependencies.map())
+            dependencies.set(pkg, packageDependencies);
         }
     });
-    dependencies.forEach(function (moduleDependencies, pkg) {
-        if (!moduleDependencies.some(function (dependency) {
-            return typeof dependency !== 'string' && lincdPackages.has(dependency.moduleName);
+    dependencies.forEach(function (PackageDependencies, pkg) {
+        if (!PackageDependencies.some(function (dependency) {
+            return typeof dependency !== 'string' && lincdPackages.has(dependency.packageName);
         })) {
-            leastDependentModule = pkg;
+            leastDependentPackage = pkg;
         }
     });
-    var startStack = [leastDependentModule];
+    var startStack = [leastDependentPackage];
     var done = new Set();
     var results = [];
     var runStack = function (stack) { return __awaiter(_this, void 0, void 0, function () {
@@ -327,8 +329,8 @@ function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStack
                         // p = p.then(() => {
                         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:'));
+                            warn('Uncaught exception whilst running parallel function on ' + pck.packageName, error.message);
+                            // warn(chalk.red(pck.packageName+' failed:'));
                             // console.log(stdout);
                         })
                             .then(function (res) {
@@ -349,7 +351,7 @@ function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStack
                         //but every dependency is now done OR was not something we can build (some @dacore dependencies may not be local)
                         if (!done.has(pkg) &&
                             deps.every(function (dependency) {
-                                return typeof dependency !== 'string' && (done.has(dependency) || !lincdPackages.has(dependency.moduleName));
+                                return typeof dependency !== 'string' && (done.has(dependency) || !lincdPackages.has(dependency.packageName));
                             })) {
                             stack.push(pkg);
                         }
@@ -376,7 +378,7 @@ function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStack
 function buildAll(target, target2) {
     var _this = this;
     console.log('Building all LINCD packages of this repository in order of dependencies');
-    var lincdPackages = getLocalLincdModuleMap();
+    var lincdPackages = getLocalLincdPackageMap();
     var startFrom;
     //by default start building
     var building = true;
@@ -396,61 +398,61 @@ function buildAll(target, target2) {
     var done = new Set();
     var failedModules = [];
     progressUpdate(lincdPackages.size + ' packages left');
-    var modulesLeft = lincdPackages.size;
-    // let modulesLeft = lincdPackages.size - done.size;
+    var packagesLeft = lincdPackages.size;
+    // let packagesLeft = 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; })));
+        debugInfo('Now building: ' + chalk.blue(packageGroup.map(function (i) { return i.packageName; })));
         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) {
+                    if (pkg.packageName == startFrom || pkg.packageName == startFrom) {
                         building = true;
                     }
                     //else still waiting for the package
                     else {
-                        log(chalk.blue('skipping ' + pkg.moduleName));
+                        log(chalk.blue('skipping ' + pkg.packageName));
                         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));
+                    debugInfo(chalk.cyan('Building ' + pkg.packageName));
                 }
                 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);
+                        warn('Failed to build ' + pkg.packageName);
                         console.log(stdout);
-                        failedModules.push(pkg.moduleName);
+                        failedModules.push(pkg.packageName);
                         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 +
+                                pkg.packageName +
                                 ', which ' +
                                 dependentModules.length +
-                                ' other packages depend on.')); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                                ' other packages depend on.')); //"+dependentModules.map(d => d.packageName).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(", ")));
+                                chalk.green("lincd build-all from ".concat(pkg.packageName)) +
+                                ' to build only the remaining packages'); //"+dependentModules.map(d => d.packageName).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) {
+                        packagesLeft--;
+                        // log(chalk.magenta(packagesLeft + ' packages left'));
+                        process.stdout.write(packagesLeft + ' packages left\r');
+                        if (packagesLeft == 0) {
                             printBuildResults(failedModules, done);
                         }
                         return res;
@@ -473,14 +475,14 @@ function buildAll(target, target2) {
                         first_1 = false;
                     }
                     //print the cyclical dependencies
-                    console.log(chalk.red(pkg.moduleName) +
+                    console.log(chalk.red(pkg.packageName) +
                         ' depends on ' +
                         deps
                             .filter(function (dependency) {
                             return typeof dependency !== 'string';
                         })
                             .map(function (d) {
-                            return done.has(d) ? d.moduleName : chalk.red(d.moduleName);
+                            return done.has(d) ? d.packageName : chalk.red(d.packageName);
                         })
                             .join(', '));
                     //also print some information why these packages have not been moved into the stack
@@ -508,24 +510,24 @@ function getDependentPackages(dependencies, pkg) {
  * 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) {
+function getLocalLincdPackageMap(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
     var map = new Map();
-    getLincdModules(rootPath).forEach(function (pkg) {
+    getLincdPackages(rootPath).forEach(function (pkg) {
         if (pkg.path.indexOf('../') === -1 && pkg.path.indexOf('..\\') === -1) {
             // console.log(package.path);
-            map.set(pkg.moduleName, pkg);
+            map.set(pkg.packageName, pkg);
         }
     });
     return map;
 }
 function getLocalLincdModules(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
-    return getLincdModules(rootPath).filter(function (pkg) {
+    return getLincdPackages(rootPath).filter(function (pkg) {
         return pkg.path.indexOf('..\\') === -1;
     });
 }
-function getLincdModules(rootPath) {
+function getLincdPackages(rootPath) {
     if (rootPath === void 0) { rootPath = process.cwd(); }
     var pack = (0, utils_1.getPackageJSON)();
     if (!pack || !pack.workspaces) {
@@ -686,11 +688,11 @@ var createOntology = function (prefix, uriBase, basePath) {
                     //copy ontology accessor file
                     log("Creating files for ontology '" + prefix + "'");
                     targetFile = path.join(targetFolder, hyphenName + '.ts');
-                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
                     targetDataFile = path.join(targetFolder, '..', 'data', hyphenName + '.json');
                     targetDataFile2 = path.join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
-                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json'), targetDataFile);
-                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json'), targetDataFile);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
                     return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetDataFile, targetDataFile2)];
                 case 1:
                     _b.sent();
@@ -781,7 +783,7 @@ var ensureFolderExists = function () {
         fs.mkdirSync(targetFolder);
       } else {
         warn(
-          `Please run this command from the root of your module. This command expects ${parentDirectory.toString()} to exists from that folder`,
+          `Please run this command from the root of your package. This command expects ${parentDirectory.toString()} to exists from that folder`,
         );
       }
     }
@@ -789,7 +791,7 @@ var ensureFolderExists = function () {
 };
 var setNameVariables = function (name) {
     var hyphenName = name.replace(/[-_\s]+/g, '-');
-    var camelCaseName = camelCase(name); //some-module --> someModule
+    var camelCaseName = camelCase(name); //some-package --> someModule
     var underscoreName = name.replace(/[-\s]+/g, '_');
     //longer similar variables names should come before the shorter ones
     setVariable('underscore_name', underscoreName);
@@ -850,7 +852,7 @@ var createComponent = function (name, basePath) {
         });
     });
 };
-var createModule = function (name, uriBase, basePath) {
+var createPackage = function (name, uriBase, basePath) {
     if (basePath === void 0) { basePath = process.cwd(); }
     return __awaiter(void 0, void 0, void 0, function () {
         var _a, packageName, scope, cleanPackageName, targetFolder, _b, hyphenName, camelCaseName, underscoreName, version, installCommand;
@@ -859,8 +861,8 @@ var createModule = function (name, uriBase, basePath) {
                 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 packages folder, if it exists we go into that.
-                    if (fs.existsSync(path.join(basePath, 'modules'))) {
-                        basePath = path.join(basePath, 'modules');
+                    if (fs.existsSync(path.join(basePath, 'packages'))) {
+                        basePath = path.join(basePath, 'packages');
                     }
                     if (!name) {
                         console.warn('Please provide a name as the first argument');
@@ -877,13 +879,13 @@ var createModule = function (name, uriBase, basePath) {
                     // --> match[0] = @dacore/some-mod
                     // --> match[1] = @dacore
                     // --> match[2] = some-mod
-                    //but save full scoped package name under ${module_name}
-                    setVariable('module_name', name);
+                    //but save full scoped package name under ${package_name}
+                    setVariable('package_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 package '" + name + "'");
-                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module'), targetFolder);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package'), targetFolder);
                     //replace variables in some of the copied files
                     return [4 /*yield*/, Promise.all([
                             'src/index.ts',
@@ -997,7 +999,7 @@ var buildFailed = function (output) {
         var pack = JSON.parse(
             fs.readFileSync(process.cwd() + '/package.json', 'utf8'),
         );
-        let moduleName = pack.name;
+        let packageName = pack.name;
 
         //just making sure the library is loaded in correct order because circular references are currently happening when importing BlankNode before NamedNode for example
         // require('lincd');
@@ -1008,7 +1010,7 @@ var buildFailed = function (output) {
             let shapeJSONLD = await getShapesJSONLD(indexExports.packageExports);
             console.log(indexExports.packageExports);
             console.log(shapeJSONLD);
-            console.log(chalk.bold(chalk.green(moduleName+'/dist/shapes.json')));
+            console.log(chalk.bold(chalk.green(packageName+'/dist/shapes.json')));
             return fs.writeFile(path.join('dist', 'shapes.json'), shapeJSONLD);
         }
         else
@@ -1024,7 +1026,7 @@ var register = function (registryURL) {
     if (fs.existsSync(process.cwd() + '/package.json')) {
         var pack = JSON.parse(fs.readFileSync(process.cwd() + '/package.json', 'utf8'));
         var version = pack.version;
-        var moduleName = pack.name;
+        var packageName = pack.name;
         // let author = pack.author;
         // let description = pack.description;
         //
@@ -1032,14 +1034,14 @@ var register = function (registryURL) {
         // if (pack.author.name) {
         //   authorName = pack.author.name;
         // }
-        console.log(chalk.cyan('registering package ' + moduleName + ' ' + version + ' in the LINCD registry'));
+        console.log(chalk.cyan('registering package ' + packageName + ' ' + version + ' in the LINCD registry'));
         return fetch(registryURL + '/register', {
             method: 'POST',
             headers: {
                 Accept: 'application/json, text/plain, */*',
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify({ package: moduleName, version: version })
+            body: JSON.stringify({ package: packageName, version: version })
         })
             .then(function (res) { return res.json(); })
             .then(function (json) {
@@ -1060,12 +1062,12 @@ var register = function (registryURL) {
         console.warn(chalk.red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
     }
 };
-var buildModule = function (target, target2, modulePath, logResults) {
-    if (modulePath === void 0) { modulePath = process.cwd(); }
+var buildPackage = function (target, target2, packagePath, logResults) {
+    if (packagePath === void 0) { packagePath = process.cwd(); }
     if (logResults === void 0) { logResults = true; }
     if (target == 'production' || target == 'es5' || target == 'es6' || !target) {
-        if (!fs.existsSync(path.join(modulePath, 'Gruntfile.js'))) {
-            console.warn("No Gruntfile found at ".concat(modulePath, "\\Gruntfile.js. Cannot build."));
+        if (!fs.existsSync(path.join(packagePath, 'Gruntfile.js'))) {
+            console.warn("No Gruntfile found at ".concat(packagePath, "\\Gruntfile.js. Cannot build."));
             return;
         }
         var nodeEnv = '';
@@ -1093,7 +1095,7 @@ var buildModule = function (target, target2, modulePath, logResults) {
             ' --color');
         var method = logResults ? execp : execPromise;
         //execute the command to build the method, and provide the current work directory as option
-        return method(nodeEnv + 'grunt build' + (target ? '-' + target : '') + (target2 ? '-' + target2 : '') + ' --color', false, false, { cwd: modulePath })["catch"](function (err) {
+        return method(nodeEnv + 'grunt build' + (target ? '-' + target : '') + (target2 ? '-' + target2 : '') + ' --color', false, false, { cwd: packagePath })["catch"](function (err) {
             process.exit(1);
         });
     }
@@ -1101,21 +1103,21 @@ var buildModule = function (target, target2, modulePath, logResults) {
         console.warn('unknown build target. Use es5, es6 or production.');
     }
 };
-var getLastBuildTime = function (modulePath) {
-    return getLastModifiedFile(modulePath + '/@(builds|lib|dist)/**/*.js');
+var getLastBuildTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(builds|lib|dist)/**/*.js');
 };
-var getLastModifiedSourceTime = function (modulePath) {
-    return getLastModifiedFile(modulePath + '/@(src|data|scss)/**/*', {
-        ignore: [modulePath + '/**/*.scss.json', modulePath + '/**/*.d.ts']
+var getLastModifiedSourceTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(src|data|scss)/**/*', {
+        ignore: [packagePath + '/**/*.scss.json', packagePath + '/**/*.d.ts']
     });
 };
-var getLastCommitTime = function (modulePath) {
-    // console.log(`git log -1 --format=%ci -- ${modulePath}`);
+var getLastCommitTime = function (packagePath) {
+    // console.log(`git log -1 --format=%ci -- ${packagePath}`);
     // process.exit();
-    return execPromise("git log -1 --format=%ci -- ".concat(modulePath))
+    return execPromise("git log -1 --format=%ci -- ".concat(packagePath))
         .then(function (result) {
         var lastCommit = new Date(result);
-        // console.log(modulePath,result,lastCommit);
+        // console.log(packagePath,result,lastCommit);
         return lastCommit;
     })["catch"](function (_a) {
         var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
@@ -1156,8 +1158,8 @@ var publishUpdated = function (test) {
     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) {
-            progressUpdate(packagesLeft-- + ' packages left. Now checking ' + pckg.moduleName);
-            debugInfo('# Checking package ' + pckg.moduleName);
+            progressUpdate(packagesLeft-- + ' packages left. Now checking ' + pckg.packageName);
+            debugInfo('# Checking package ' + pckg.packageName);
             // 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());
@@ -1168,7 +1170,7 @@ var publishUpdated = function (test) {
             if (pack.private) {
                 shouldPublish = false;
                 debugInfo(chalk.blue('--> is private, skipping'));
-                return previousResult + ' ' + chalk.gray(pckg.moduleName + ' is private\n');
+                return previousResult + ' ' + chalk.gray(pckg.packageName + ' is private\n');
             }
             return execPromise('yarn info ' + pckg.packageName + ' --json')
                 .then(function (output) { return __awaiter(_this, void 0, void 0, function () {
@@ -1188,13 +1190,13 @@ var publishUpdated = function (test) {
                                 else {
                                     info = JSON.parse(output);
                                 }
-                                // var stats = fs.statSync(path.join(moduleDirectory));
-                                // var files = fs.readdirSync(path.join(moduleDirectory,'src'));
+                                // var stats = fs.statSync(path.join(packageDirectory));
+                                // var files = fs.readdirSync(path.join(packageDirectory,'src'));
                             }
                             catch (err) {
-                                chalk.red(pckg.moduleName + ' failed: ' + err.message + '\n');
+                                chalk.red(pckg.packageName + ' failed: ' + err.message + '\n');
                                 console.warn('Returned JSON from npm: ' + output);
-                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.moduleName + ' failed: ' + err.message + '\n')];
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.packageName + ' failed: ' + err.message + '\n')];
                             }
                             if (!info) return [3 /*break*/, 2];
                             lastPublish = info.data.time[info.data.version];
@@ -1205,7 +1207,7 @@ var publishUpdated = function (test) {
                             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')];
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.packageName + ' - 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
@@ -1224,12 +1226,12 @@ var publishUpdated = function (test) {
                         case 2:
                             if (shouldPublish) {
                                 res = publishPackage(pckg, previousResult, test, info, version);
-                                if (pckg.moduleName == 'browser-core') {
+                                if (pckg.packageName == 'browser-core') {
                                     browserCoreBuilt = true;
                                 }
                                 //when publishing core, also make sure to publish browser-core
-                                if (pckg.moduleName == 'core' && !browserCoreBuilt) {
-                                    browserModule = packages.find(function (m) { return m.moduleName == 'browser-core'; });
+                                if (pckg.packageName == 'core' && !browserCoreBuilt) {
+                                    browserModule = packages.find(function (m) { return m.packageName == 'browser-core'; });
                                     return [2 /*return*/, Promise.resolve(res).then(function (previousResult) {
                                             log('# Automatically also publishing package browser-core');
                                             return publishPackage(browserModule, previousResult, test);
@@ -1243,7 +1245,7 @@ var publishUpdated = function (test) {
             }); })["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 previousResult + ' ' + chalk.red(pckg.packageName + ' failed\n');
             });
         });
     });
@@ -1261,10 +1263,10 @@ var publishPackage = function (pkg, previousResult, test, info, publishVersion)
         publishVersion = info ? getNextVersion(info.data.version) : '';
     }
     if (test) {
-        debugInfo('should publish ' + pkg.moduleName + ' ' + publishVersion);
+        debugInfo('should publish ' + pkg.packageName + ' ' + publishVersion);
     }
     else {
-        console.log(chalk.blue('publishing ' + pkg.moduleName + ' ' + publishVersion));
+        console.log(chalk.blue('publishing ' + pkg.packageName + ' ' + publishVersion));
     }
     if (!test) {
         return execPromise("cd ".concat(pkg.path, " && yarn publish").concat(publishVersion ? ' --new-version ' + publishVersion : ''), true, false, {}, true)
@@ -1273,19 +1275,19 @@ var publishPackage = function (pkg, previousResult, test, info, publishVersion)
                 res.indexOf('Could not publish') !== -1 ||
                 res.indexOf("Couldn't publish") !== -1) {
                 console.log(res);
-                return previousResult + ' ' + chalk.red(pkg.moduleName + ' failed\n');
+                return previousResult + ' ' + chalk.red(pkg.packageName + ' failed\n');
             }
             console.log(chalk.green('Successfully published ' + pkg.path + ' ' + publishVersion));
-            return previousResult + ' ' + chalk.green(pkg.moduleName + ' published ' + publishVersion + '\n');
+            return previousResult + ' ' + chalk.green(pkg.packageName + ' 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');
+            return previousResult + ' ' + chalk.red(pkg.packageName + ' failed to publish\n');
         });
     }
     else {
         //when testing what needs to be published
-        return previousResult + ' ' + chalk.blue(pkg.moduleName + ' should publish\n');
+        return previousResult + ' ' + chalk.blue(pkg.packageName + ' should publish\n');
     }
 };
 var buildUpdated = function (back, target, target2, test) {
@@ -1298,7 +1300,7 @@ var buildUpdated = function (back, target, target2, test) {
                 case 0:
                     previousResult = '';
                     log(test ? 'Checking which packages need to be rebuild' : 'Building updated packages');
-                    packages = getLocalLincdModuleMap();
+                    packages = getLocalLincdPackageMap();
                     jsonldPkgUpdated = needsRebuilding(packages.get('lincd-jsonld'));
                     cliPkgUpdated = needsRebuilding(packages.get('lincd-cli'));
                     if (!(jsonldPkgUpdated || cliPkgUpdated)) return [3 /*break*/, 2];
@@ -1310,46 +1312,46 @@ var buildUpdated = function (back, target, target2, test) {
                     rebuildAllModules = false;
                     if (cliPkgUpdated) {
                         rebuildAllModules = true;
-                        log(chalk.magenta('Rebuilding all modules because the build tools (lincd-cli) got updated'));
+                        log(chalk.magenta('Rebuilding all packages 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('Now checking: ' + chalk.blue(packageGroup.map((i) => i.packageName)));
                         // 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);
+                                debugInfo('# Checking package ' + pkg.packageName);
                                 needRebuild = needsRebuilding(pkg, true);
-                                if (pkg.moduleName === 'lincd-jsonld' && jsonldPkgUpdated) {
+                                if (pkg.packageName === '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());
+                                    // log(packageName+' 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')];
+                                        debugInfo('Need to build ' + pkg.packageName);
+                                        return [2 /*return*/, chalk.blue(pkg.packageName + ' should be build')];
                                     }
-                                    log('Building ' + pkg.moduleName);
+                                    log('Building ' + pkg.packageName);
                                     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');
+                                            debugInfo(chalk.green(pkg.packageName + ' successfully built'));
+                                            return chalk.green(pkg.packageName + ' built');
                                         })["catch"](function (_a) {
                                             var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
-                                            warn('Failed to build ' + pkg.moduleName);
+                                            warn('Failed to build ' + pkg.packageName);
                                             console.log(stdout);
                                             var dependentModules = getDependentPackages(dependencies, pkg);
                                             if (dependentModules.length > 0) {
                                                 // printBuildResults(failedModules, done);
-                                                warn(chalk.red(pkg.moduleName + ' build failed'));
+                                                warn(chalk.red(pkg.packageName + ' build failed'));
                                                 warn('Stopping build-updated process because ' +
                                                     dependentModules.length +
-                                                    ' other packages depend on this module.\n'); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                                                    ' other packages depend on this package.\n'); //"+dependentModules.map(d => d.packageName).join(", ")));
                                                 process.exit(1);
                                             }
                                         })];
@@ -1389,18 +1391,18 @@ var needsRebuilding = function (pkg, logDetailsIfTrue) {
     return result;
 };
 var printBuildResults = function (failed, done) {
-    log('Successfully built: ' + chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.moduleName; }).join(', ')) + '\n');
+    log('Successfully built: ' + chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.packageName; }).join(', ')) + '\n');
     if (failed.length > 0) {
         warn('Failed to build: ' + chalk.red(failed.join(', ')) + '\n');
     }
 };
-var executeCommandForEachModule = function (packages, command, filterMethod, filterValue) {
+var executeCommandForEachPackage = function (packages, command, filterMethod, filterValue) {
     //if a specific set of packages is given
     if (filterMethod == 'exclude') {
         //filter packages, so that we only execute on the packages as provided in the command
         log('Excluding ' + filterValue);
         filterValue = filterValue.split(',');
-        packages = packages.filter(function (pkg) { return filterValue.indexOf(pkg.moduleName) === -1; });
+        packages = packages.filter(function (pkg) { return filterValue.indexOf(pkg.packageName) === -1; });
     }
     var startFrom;
     //by default start executing, unless 'from' is given
@@ -1413,7 +1415,7 @@ var executeCommandForEachModule = function (packages, command, filterMethod, fil
         }
         var seen_1 = false;
         packages = packages.filter(function (pkg) {
-            if (!seen_1 && (pkg.moduleName == startFrom || pkg.packageName == startFrom)) {
+            if (!seen_1 && (pkg.packageName == startFrom || pkg.packageName == startFrom)) {
                 seen_1 = true;
             }
             return seen_1;
@@ -1422,26 +1424,26 @@ var executeCommandForEachModule = function (packages, command, filterMethod, fil
     log("Executing '" +
         chalk.blueBright(command) +
         "' on packages " +
-        chalk.magenta(packages.map(function (m) { return m.moduleName; }).join(', ')));
+        chalk.magenta(packages.map(function (m) { return m.packageName; }).join(', ')));
     var p = Promise.resolve(true);
     packages.forEach(function (pkg) {
         p = p.then(function () {
-            log('# Package ' + chalk.magenta(pkg.moduleName));
+            log('# Package ' + chalk.magenta(pkg.packageName));
             return execp('cd ' + pkg.path + ' && ' + command);
         });
     });
     return p;
 };
-var executeCommandForModule = function (moduleName, command) {
-    var moduleDetails = getLincdModules().find(function (modDetails) {
-        return modDetails.packageName.indexOf(moduleName) !== -1 || modDetails.moduleName.indexOf(moduleName) !== -1;
+var executeCommandForPackage = function (packageName, command) {
+    var packageDetails = getLincdPackages().find(function (modDetails) {
+        return modDetails.packageName.indexOf(packageName) !== -1 || modDetails.packageName.indexOf(packageName) !== -1;
     });
-    if (moduleDetails) {
-        log("Executing 'cd " + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
-        return execp('cd ' + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
+    if (packageDetails) {
+        log("Executing 'cd " + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
+        return execp('cd ' + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
     }
     else {
-        warn("Could not find a pkg who's name (partially) matched " + chalk.cyan(moduleName));
+        warn("Could not find a pkg who's name (partially) matched " + chalk.cyan(packageName));
     }
 };
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lincd-cli",
-  "version": "0.1.24",
+  "version": "0.2.1",
   "description": "Command line tools for the lincd.js library",
   "main": "lib/index.js",
   "scripts": {
@@ -54,7 +54,7 @@
     "grunt-ts": "^6.0.0-beta.22",
     "grunt-webpack": "^5.0.0",
     "license-info-webpack-plugin": "^3.0.0",
-    "lincd": "^0.3.6",
+    "lincd": "^0.4",
     "lincd-jsonld": "^0.1.8",
     "load-grunt-tasks": "^5.1.0",
     "mini-css-extract-plugin": "^2.6.1",