lincd-cli 0.2.10 → 0.2.12

package/lib/cli-methods.js

@@ -0,0 +1,1548 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.executeCommandForPackage = exports.addCapacitor = exports.executeCommandForEachPackage = exports.buildUpdated = exports.publishUpdated = exports.buildPackage = exports.buildMetadata = exports.register = exports.createPackage = exports.createComponent = exports.createSetComponent = exports.createShape = exports.createOntology = exports.getLincdPackages = exports.buildAll = exports.developPackage = exports.createApp = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_extra_1 = __importDefault(require("fs-extra"));
+var utils_1 = require("./utils");
+var chalk_1 = __importDefault(require("chalk"));
+var child_process_1 = require("child_process");
+var package_metadata_js_1 = require("lincd-modules/lib/scripts/package-metadata.js");
+var models_1 = require("lincd/lib/models");
+var Module_1 = require("lincd-modules/lib/shapes/Module");
+var env_cmd_1 = require("env-cmd");
+var JSONLDWriter_1 = require("lincd-jsonld/lib/utils/JSONLDWriter");
+var NameSpace_1 = require("lincd/lib/utils/NameSpace");
+var Prefix_1 = require("lincd/lib/utils/Prefix");
+var glob = require('glob');
+var variables = {};
+var open = require('open');
+var gruntConfig;
+var createApp = function (name, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, hyphenName, camelCaseName, underscoreName, targetFolder, hasYarn, installCommand;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!name) {
+                        console.warn('Please provide a name as the first argument');
+                    }
+                    _a = setNameVariables(name), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    targetFolder = path_1["default"].join(basePath, hyphenName);
+                    if (!fs_extra_1["default"].existsSync(targetFolder)) {
+                        fs_extra_1["default"].mkdirSync(targetFolder);
+                    }
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'app-with-backend'), targetFolder);
+                    fs_extra_1["default"].renameSync(path_1["default"].join(targetFolder, '.yarnrc.yml.template'), path_1["default"].join(targetFolder, '.yarnrc.yml'));
+                    // fs.copySync(path.join(__dirname, '..', 'defaults', 'app'), targetFolder);
+                    log("Creating new LINCD application '" + name + "'");
+                    //replace variables in some copied files
+                    replaceVariablesInFilesWithRoot(targetFolder, 'package.json', 'frontend/src/App.tsx', 'frontend/src/package.ts', 'frontend/src/App.scss.json', '.vscode/launch.json', 'frontend/src/components/Spinner.scss.json');
+                    return [4 /*yield*/, hasYarnInstalled()];
+                case 1:
+                    hasYarn = _b.sent();
+                    installCommand = hasYarn ? 'yarn install' : 'npm install';
+                    return [4 /*yield*/, (0, utils_1.execp)("cd ".concat(hyphenName, " && ").concat(installCommand), true)["catch"](function (err) {
+                            console.warn('Could not install dependencies or start application');
+                        })];
+                case 2:
+                    _b.sent();
+                    log("Your LINCD App is ready at ".concat(chalk_1["default"].blueBright(targetFolder)), "To start, run\n".concat(chalk_1["default"].blueBright("cd ".concat(hyphenName)), " and then ").concat(chalk_1["default"].blueBright((hasYarn ? 'yarn' : 'npm') + ' start')));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createApp = createApp;
+function logHelp() {
+    (0, utils_1.execp)('yarn lincd help');
+}
+function log() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk_1["default"].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 && gruntConfig.analyse === true) {
+        messages.forEach(function (message) {
+            console.log(chalk_1["default"].cyan('Info: ') + message);
+        });
+    }
+}
+function warn() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk_1["default"].magenta('Warning: ') + message);
+        // console.log(chalk.red(message));
+    });
+}
+function developPackage(target, mode) {
+    if (!target)
+        target = 'es6';
+    if (mode !== 'production')
+        mode = '';
+    else if (target !== 'es6')
+        log('target must be es6 when developing for production');
+    if (target == 'es5' || target == 'es6') {
+        // log('> Starting continuous development build for '+target+' target')
+        log('starting continuous development build');
+        log('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
+        var command = (0, child_process_1.exec)('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
+        command.stdout.pipe(process.stdout);
+        command.stderr.pipe(process.stderr);
+    }
+    else {
+        console.warn('unknown build target. Use es5 or es6');
+    }
+}
+exports.developPackage = developPackage;
+function checkWorkspaces(rootPath, workspaces, res) {
+    // console.log('checking workspaces at '+rootPath+": "+workspaces.toString());
+    if (workspaces.packages) {
+        workspaces = workspaces.packages;
+    }
+    workspaces.forEach(function (workspace) {
+        var workspacePath = path_1["default"].join(rootPath, workspace.replace('/*', ''));
+        if (workspace.indexOf('/*') !== -1) {
+            // console.log(workspacePath);
+            if (fs_extra_1["default"].existsSync(workspacePath)) {
+                var folders = fs_extra_1["default"].readdirSync(workspacePath);
+                folders.forEach(function (folder) {
+                    if (folder !== './' && folder !== '../') {
+                        checkPackagePath(rootPath, path_1["default"].join(workspacePath, folder), res);
+                    }
+                });
+            }
+        }
+        else {
+            checkPackagePath(rootPath, workspacePath, res);
+        }
+    });
+}
+function checkPackagePath(rootPath, packagePath, res) {
+    var packageJsonPath = path_1["default"].join(packagePath, 'package.json');
+    // console.log('checking '+packagePath);
+    if (fs_extra_1["default"].existsSync(packageJsonPath)) {
+        var pack = JSON.parse(fs_extra_1["default"].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(packagePath, pack.workspaces, res);
+        }
+        else if (pack && pack.lincd === true) {
+            res.push({
+                path: packagePath,
+                packageName: pack.name
+            });
+        }
+    }
+}
+function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd) {
+    var _this = this;
+    var dependencies = new Map();
+    //get dependencies of each package
+    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 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.packageName,packageDependencies.map())
+            dependencies.set(pkg, packageDependencies);
+        }
+    });
+    dependencies.forEach(function (PackageDependencies, pkg) {
+        if (!PackageDependencies.some(function (dependency) {
+            return typeof dependency !== 'string' && lincdPackages.has(dependency.packageName);
+        })) {
+            leastDependentPackage = pkg;
+        }
+    });
+    var startStack = [leastDependentPackage];
+    var done = new Set();
+    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:
+                    runFunction = onBuildStack(stack, dependencies);
+                    stackPromise = Promise.all(stack.map(function (pck) {
+                        // 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.packageName, error.message);
+                            // warn(chalk.red(pck.packageName+' failed:'));
+                            // console.log(stdout);
+                        })
+                            .then(function (res) {
+                            done.add(pck);
+                            return res;
+                        });
+                    }));
+                    return [4 /*yield*/, stackPromise];
+                case 1:
+                    stackResults = _a.sent();
+                    results = results.concat(stackResults);
+                    //clear stack for next round
+                    stack = [];
+                    //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(pkg) &&
+                            deps.every(function (dependency) {
+                                return typeof dependency !== 'string' && (done.has(dependency) || !lincdPackages.has(dependency.packageName));
+                            })) {
+                            stack.push(pkg);
+                        }
+                        // else if(!done.has(package))
+                        // {
+                        // 	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(stack)];
+                    }
+                    else {
+                        onStackEnd(dependencies, results.filter(Boolean));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    //starts the process
+    runStack(startStack);
+}
+function buildAll(target, target2, target3) {
+    var _this = this;
+    console.log('Building all LINCD packages of this repository in order of dependencies');
+    var lincdPackages = getLocalLincdPackageMap();
+    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_1["default"].blue('Will skip builds until ' + startFrom));
+        // return async (pkg) => {};
+    }
+    if (target2 == 'from') {
+        startFrom = target3;
+        //if we have a startFrom, then we havnt started the build process yet
+        building = startFrom ? false : true;
+        //clear targets
+        target2 = '';
+        target3 = '';
+        console.log(chalk_1["default"].blue('Will skip builds until ' + startFrom));
+        // return async (pkg) => {};
+    }
+    var done = new Set();
+    var failedModules = [];
+    progressUpdate(lincdPackages.size + ' packages left');
+    var packagesLeft = lincdPackages.size;
+    // let packagesLeft = lincdPackages.size - done.size;
+    runOnPackagesGroupedByDependencies(lincdPackages, function (packageGroup, dependencies) {
+        if (done.size > 0) {
+            debugInfo(chalk_1["default"].magenta('\n-------\nThese packages are next, since all their dependencies have now been build:'));
+            // log(stack);
+        }
+        debugInfo('Now building: ' + chalk_1["default"].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.packageName == startFrom || pkg.packageName == startFrom) {
+                        building = true;
+                    }
+                    //else still waiting for the package
+                    else {
+                        log(chalk_1["default"].blue('skipping ' + pkg.packageName));
+                        command = Promise.resolve(true);
+                    }
+                }
+                //unless told otherwise, build the package
+                if (!command) {
+                    command = (0, utils_1.execPromise)('cd ' + pkg.path + ' && yarn lincd build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''), false, false, {}, false);
+                    debugInfo(chalk_1["default"].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.packageName);
+                        console.log(stdout);
+                        failedModules.push(pkg.packageName);
+                        var dependentModules = getDependentPackages(dependencies, pkg);
+                        if (dependentModules.length > 0) {
+                            printBuildResults(failedModules, done);
+                            console.log(chalk_1["default"].magenta('Stopping build process because an error occurred whilst building ' +
+                                pkg.packageName +
+                                ', which ' +
+                                dependentModules.length +
+                                ' other packages depend on.')); //"+dependentModules.map(d => d.packageName).join(", ")));
+                            console.log(chalk_1["default"].cyanBright('tip ') +
+                                'Run ' +
+                                chalk_1["default"].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) {
+                        log(chalk_1["default"].green('Built ' + pkg.packageName));
+                        done.add(pkg);
+                        packagesLeft--;
+                        // log(chalk.magenta(packagesLeft + ' packages left'));
+                        process.stdout.write(packagesLeft + ' packages left\r');
+                        if (packagesLeft == 0) {
+                            printBuildResults(failedModules, done);
+                        }
+                        return res;
+                    })];
+            });
+        }); };
+    }, function (dependencies) {
+        //if no more packages to build but we never started building...
+        if (!building) {
+            console.log(chalk_1["default"].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_1["default"].red('CYCLICAL DEPENDENCIES? - could not build some packages because they depend on each other.'));
+                        first_1 = false;
+                    }
+                    //print the cyclical dependencies
+                    console.log(chalk_1["default"].red(pkg.packageName) +
+                        ' depends on ' +
+                        deps
+                            .filter(function (dependency) {
+                            return typeof dependency !== 'string';
+                        })
+                            .map(function (d) {
+                            return done.has(d) ? d.packageName : chalk_1["default"].red(d.packageName);
+                        })
+                            .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_1["default"].red('And it depends on these package(s) - which seem not to be proper packages :' +
+                            stringDependencies.join(', ')));
+                        console.log(chalk_1["default"].red('Could you remove this from dependencies? Should it be a devDependency?'));
+                    }
+                }
+            });
+        }
+    });
+}
+exports.buildAll = buildAll;
+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 packages that this repository manages (so no packages found through the workspaces who's path contains ../ )
+ * @param rootPath
+ */
+function getLocalLincdPackageMap(rootPath) {
+    if (rootPath === void 0) { rootPath = './'; }
+    var map = new Map();
+    getLincdPackages(rootPath).forEach(function (pkg) {
+        if (pkg.path.indexOf('../') === -1 && pkg.path.indexOf('..\\') === -1) {
+            // console.log(package.path);
+            map.set(pkg.packageName, pkg);
+        }
+    });
+    return map;
+}
+function getLocalLincdModules(rootPath) {
+    if (rootPath === void 0) { rootPath = './'; }
+    return getLincdPackages(rootPath).filter(function (pkg) {
+        return pkg.path.indexOf('..\\') === -1;
+    });
+}
+function getLincdPackages(rootPath) {
+    if (rootPath === void 0) { rootPath = process.cwd(); }
+    var pack = (0, utils_1.getPackageJSON)();
+    if (!pack || !pack.workspaces) {
+        for (var i = 0; i <= 3; i++) {
+            rootPath = path_1["default"].join.apply(path_1["default"], __spreadArray([process.cwd()], __read(Array(i).fill('..')), false));
+            pack = (0, utils_1.getPackageJSON)(rootPath);
+            if (pack && pack.workspaces) {
+                // log('Found workspace at '+packagePath);
+                break;
+            }
+        }
+    }
+    if (!pack || !pack.workspaces) {
+        warn(chalk_1["default"].red('Could not find package workspaces. Make sure you run this command from a yarn workspace.'));
+        logHelp();
+        process.exit();
+    }
+    // console.log(pack.workspaces);
+    var res = [];
+    checkWorkspaces(rootPath, pack.workspaces, res);
+    return res;
+}
+exports.getLincdPackages = getLincdPackages;
+function setVariable(name, replacement) {
+    //prepare name for regexp
+    name = name.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    variables[name] = replacement;
+}
+var replaceVariablesInFile = function (filePath) { return __awaiter(void 0, void 0, void 0, function () {
+    var fileContent, newContent;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fs_extra_1["default"].readFile(filePath, 'utf8')];
+            case 1:
+                fileContent = _a.sent();
+                newContent = replaceCurlyVariables(fileContent);
+                return [2 /*return*/, fs_extra_1["default"].writeFile(filePath, newContent)];
+        }
+    });
+}); };
+var replaceCurlyVariables = function (string) {
+    // var reg = new RegExp('\\$\\{'+key+'\\}','g');
+    for (var key in variables) {
+        string = string.replace(new RegExp('\\$\\{' + key + '\\}', 'g'), variables[key]);
+    }
+    return 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(' ');
+    if (string.length > 1) {
+        return string.reduce(function (result, word) { return result + capitalize(word); });
+    }
+    return str;
+};
+var createOntology = function (prefix, uriBase, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var sourceFolder, targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, targetDataFile, targetDataFile2, indexPath;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!prefix) {
+                        console.warn('Please provide a suggested prefix as the first argument');
+                        return [2 /*return*/];
+                    }
+                    sourceFolder = getSourceFolder(basePath);
+                    targetFolder = ensureFolderExists(sourceFolder, 'ontologies');
+                    if (!uriBase) {
+                        uriBase = 'http://lincd.org/ont/' + prefix + '/';
+                    }
+                    setVariable('uri_base', uriBase);
+                    _a = setNameVariables(prefix), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    //copy ontology accessor file
+                    log("Creating files for ontology '" + prefix + "'");
+                    targetFile = path_1["default"].join(targetFolder, hyphenName + '.ts');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+                    targetDataFile = path_1["default"].join(targetFolder, '..', 'data', hyphenName + '.json');
+                    targetDataFile2 = path_1["default"].join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json'), targetDataFile);
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetDataFile, targetDataFile2)];
+                case 1:
+                    _b.sent();
+                    log("Prepared a new ontology data files in ".concat(chalk_1["default"].magenta(targetDataFile.replace(basePath, ''))), "And an ontology accessor file in ".concat(chalk_1["default"].magenta(targetFile.replace(basePath, ''))));
+                    //if this is not a lincd app (but a lincd package instead)
+                    if (!sourceFolder.includes('frontend')) {
+                        indexPath = addLineToIndex("import './ontologies/".concat(hyphenName, "';"), 'ontologies');
+                        log("Added an import of this file from ".concat(chalk_1["default"].magenta(indexPath)));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createOntology = createOntology;
+var addLineToIndex = function (line, insertMatchString) {
+    //import ontology in index
+    var indexPath = ['index.ts', 'index.tsx']
+        .map(function (f) { return path_1["default"].join('src', f); })
+        .find(function (indexFileName) {
+        return fs_extra_1["default"].existsSync(indexFileName);
+    });
+    if (indexPath) {
+        var indexContents = fs_extra_1["default"].readFileSync(indexPath, 'utf-8');
+        var lines = indexContents.split(/\n/g);
+        var newContents = void 0;
+        for (var key in lines) {
+            if (lines[key].indexOf(insertMatchString) !== -1) {
+                //remove lines after this line and insert new line in its place
+                lines[key] += "\n".concat(line);
+                newContents = lines.join('\n');
+                // log("Found at "+key,lines,newContents);
+                break;
+            }
+        }
+        if (!newContents) {
+            newContents = indexContents + "\n".concat(line);
+            // log("Added at end",newContents);
+        }
+        fs_extra_1["default"].writeFileSync(indexPath, newContents);
+    }
+    return indexPath;
+};
+var replaceVariablesInFiles = function () {
+    var files = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        files[_i] = arguments[_i];
+    }
+    return Promise.all(files.map(function (file) {
+        return replaceVariablesInFile(file);
+    }));
+};
+var replaceVariablesInFilesWithRoot = function (root) {
+    var files = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        files[_i - 1] = arguments[_i];
+    }
+    return replaceVariablesInFiles.apply(void 0, __spreadArray([], __read(files.map(function (f) { return path_1["default"].join(root, f); })), false));
+};
+var hasYarnInstalled = function () {
+    return __awaiter(this, void 0, void 0, function () {
+        var version;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, utils_1.execPromise)('yarn --version')["catch"](function (err) {
+                        console.log('yarn probably not working');
+                        return '';
+                    })];
+                case 1:
+                    version = (_a.sent());
+                    return [2 /*return*/, version.toString().match(/[0-9]+/)];
+            }
+        });
+    });
+};
+var ensureFolderExists = function () {
+    var folders = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        folders[_i] = arguments[_i];
+    }
+    var target;
+    folders.forEach(function (folder) {
+        target = target ? path_1["default"].join(target, folder) : path_1["default"].join(folder);
+        if (!fs_extra_1["default"].existsSync(target)) {
+            fs_extra_1["default"].mkdirSync(target);
+        }
+    });
+    return target;
+    /*let targetFolder = path.join(...folders);
+    let parentDirectory = folders.slice(0, folders.length - 1);
+    if (!fs.existsSync(targetFolder)) {
+      if (fs.existsSync(path.join(...parentDirectory))) {
+        fs.mkdirSync(targetFolder);
+      } else {
+        warn(
+          `Please run this command from the root of your package. This command expects ${parentDirectory.toString()} to exists from that folder`,
+        );
+      }
+    }
+    return targetFolder;*/
+};
+var setNameVariables = function (name) {
+    var hyphenName = name.replace(/[-_\s]+/g, '-');
+    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);
+    setVariable('hyphen_name', hyphenName);
+    setVariable('camel_name', camelCaseName);
+    setVariable('name', name);
+    return { hyphenName: hyphenName, camelCaseName: camelCaseName, underscoreName: underscoreName };
+};
+function getSourceFolder(basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    //LINCD App
+    if (fs_extra_1["default"].existsSync(path_1["default"].join(basePath, 'frontend', 'src'))) {
+        return path_1["default"].join(basePath, 'frontend', 'src');
+    }
+    //LINCD package
+    if (fs_extra_1["default"].existsSync(path_1["default"].join(basePath, 'src'))) {
+        return path_1["default"].join(basePath, 'src');
+    }
+    else {
+        console.warn('Cannot find source folder');
+        return path_1["default"].join(basePath, 'src');
+    }
+}
+var createShape = function (name, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var sourceFolder, targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, indexPath;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sourceFolder = getSourceFolder(basePath);
+                    targetFolder = ensureFolderExists(sourceFolder, 'shapes');
+                    _a = setNameVariables(name), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    targetFile = path_1["default"].join(targetFolder, hyphenName + '.ts');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'shape.ts'), targetFile);
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile)];
+                case 1:
+                    //replace variables in some of the copied files
+                    _b.sent();
+                    log("Created a new shape class template in ".concat(chalk_1["default"].magenta(targetFile.replace(basePath, ''))));
+                    if (!sourceFolder.includes('frontend')) {
+                        indexPath = addLineToIndex("import './shapes/".concat(hyphenName, "';"), 'shapes');
+                        log("Added an import of this file from ".concat(chalk_1["default"].magenta(indexPath)));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createShape = createShape;
+var createSetComponent = function (name, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, targetFile2, indexPath;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    targetFolder = ensureFolderExists(basePath, 'src', 'components');
+                    _a = setNameVariables(name), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    //copy default shape file
+                    log("Creating files for set component '" + name + "'");
+                    targetFile = path_1["default"].join(targetFolder, hyphenName + '.tsx');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'set-component.tsx'), targetFile);
+                    targetFile2 = path_1["default"].join(targetFolder, hyphenName + '.scss');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'component.scss'), targetFile2);
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetFile2)];
+                case 1:
+                    //replace variables in some of the copied files
+                    _b.sent();
+                    indexPath = addLineToIndex("import './components/".concat(hyphenName, "';"), 'components');
+                    log("Created a new set component in ".concat(chalk_1["default"].magenta(targetFile.replace(basePath, ''))), "Created a new stylesheet in ".concat(chalk_1["default"].magenta(targetFile2.replace(basePath, ''))), "Added an import of this file from ".concat(chalk_1["default"].magenta(indexPath)));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createSetComponent = createSetComponent;
+var createComponent = function (name, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var sourceFolder, targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, targetFile2, indexPath;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sourceFolder = getSourceFolder(basePath);
+                    targetFolder = ensureFolderExists(sourceFolder, 'components');
+                    _a = setNameVariables(name), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    //copy default shape file
+                    log("Creating files for component '" + name + "'");
+                    targetFile = path_1["default"].join(targetFolder, hyphenName + '.tsx');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'component.tsx'), targetFile);
+                    targetFile2 = path_1["default"].join(targetFolder, hyphenName + '.scss');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'component.scss'), targetFile2);
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetFile2)];
+                case 1:
+                    //replace variables in some of the copied files
+                    _b.sent();
+                    log("Created a new component template in ".concat(chalk_1["default"].magenta(targetFile.replace(basePath, ''))), "Created component stylesheet template in ".concat(chalk_1["default"].magenta(targetFile2.replace(basePath, ''))));
+                    //if this is not a lincd app (but a lincd package instead)
+                    if (!sourceFolder.includes('frontend')) {
+                        indexPath = addLineToIndex("import './components/".concat(hyphenName, "';"), 'components');
+                        log("Added an import of this file from ".concat(chalk_1["default"].magenta(indexPath)));
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createComponent = createComponent;
+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;
+        return __generator(this, function (_c) {
+            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 packages folder, if it exists we go into that.
+                    if (fs_extra_1["default"].existsSync(path_1["default"].join(basePath, 'packages'))) {
+                        basePath = path_1["default"].join(basePath, 'packages');
+                    }
+                    if (!name) {
+                        console.warn('Please provide a name as the first argument');
+                        return [2 /*return*/];
+                    }
+                    _a = __read(name.match(/(@[\w\-]+\/)?([\w\-]+)/), 3), packageName = _a[0], scope = _a[1], cleanPackageName = _a[2];
+                    targetFolder = ensureFolderExists(basePath, cleanPackageName);
+                    if (!uriBase) {
+                        uriBase = 'http://lincd.org/ont/' + name;
+                    }
+                    setVariable('uri_base', uriBase + '/');
+                    //find @scope and the next part between 2 slashes after
+                    //so @dacore/some-mod/lib/file.js
+                    // --> match[0] = @dacore/some-mod
+                    // --> match[1] = @dacore
+                    // --> match[2] = some-mod
+                    //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_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'package'), targetFolder);
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, Promise.all([
+                            'src/index.ts',
+                            'package.json',
+                            'Gruntfile.js',
+                            'src/package.ts',
+                            'src/shapes/ExampleShapeClass.ts',
+                            'src/ontologies/example-ontology.ts',
+                            'src/data/example-ontology.json',
+                        ]
+                            .map(function (f) { return path_1["default"].join(targetFolder, f); })
+                            .map(function (file) {
+                            return replaceVariablesInFile(file);
+                        }))];
+                case 1:
+                    //replace variables in some of the copied files
+                    _c.sent();
+                    //rename these to a file name similar to the pkg name
+                    [
+                        'src/ontologies/example-ontology.ts',
+                        'src/data/example-ontology.json',
+                        'src/data/example-ontology.json.d.ts',
+                    ].forEach(function (f) {
+                        var parts = f.split('/');
+                        var newParts = __spreadArray([], __read(parts), false);
+                        var _a = __read(newParts.pop().split('.')), name = _a[0], extensions = _a.slice(1);
+                        var newName = hyphenName + '.' + extensions.join('.');
+                        console.log('rename ', path_1["default"].join(targetFolder, f), path_1["default"].join.apply(path_1["default"], __spreadArray(__spreadArray([targetFolder], __read(newParts), false), [newName], false)));
+                        fs_extra_1["default"].renameSync(path_1["default"].join(targetFolder, f), path_1["default"].join.apply(path_1["default"], __spreadArray(__spreadArray([targetFolder], __read(newParts), false), [newName], false)));
+                    });
+                    return [4 /*yield*/, (0, utils_1.execPromise)('yarn --version')["catch"](function (err) {
+                            console.log('yarn probably not working');
+                            return '';
+                        })];
+                case 2:
+                    version = (_c.sent());
+                    installCommand = version.toString().match(/[0-9]+/) ? 'yarn install' : 'npm install';
+                    return [4 /*yield*/, (0, utils_1.execp)("cd ".concat(targetFolder, " && ").concat(installCommand, " && npm exec lincd build"), true)["catch"](function (err) {
+                            console.warn('Could not install dependencies');
+                        })];
+                case 3:
+                    _c.sent();
+                    log("Prepared a new LINCD package in ".concat(chalk_1["default"].magenta(targetFolder)), "Run ".concat(chalk_1["default"].blueBright('yarn build'), " from this directory to build once"), "Or ".concat(chalk_1["default"].blueBright('yarn dev'), " to continuously rebuild on file changes"));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.createPackage = createPackage;
+var getNextVersion = function (version) {
+    var parts = version.split('.');
+    return parts[0] + '.' + parts[1] + '.' + (parseInt(parts[2]) + 1).toString();
+};
+var getNextMajorVersion = function (version) {
+    var parts = version.split('.');
+    return (parseInt(parts[0]) + 1).toString() + '.0.0';
+};
+var getNextMinorVersion = function (version) {
+    var parts = version.split('.');
+    return parts[0] + '.' + (parseInt(parts[1]) + 1).toString() + '.0';
+};
+var buildFailed = function (output) {
+    return output.indexOf('Aborted due to warnings') !== -1 && output.indexOf('Command failed') !== -1;
+};
+/*program.command('shapes').action(async () => {
+    //we've imported require-extensions from npm so that we can use this
+    //we want to avoid nodejs tripping up over @import commands in css files
+    require.extensions['.scss'] = function (sourcecode, filename) {
+        return {};
+    };
+    require.extensions['.css'] = function (sourcecode, filename) {
+        return {};
+    };
+
+    if (fs.existsSync(process.cwd() + '/package.json')) {
+        var pack = JSON.parse(
+            fs.readFileSync(process.cwd() + '/package.json', 'utf8'),
+        );
+        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');
+        //TODO: replace with actual index file from package.json, or tsconfig
+        let indexExports = require(process.cwd() + '/lib/index.js');
+        if(indexExports.packageExports)
+        {
+            let shapeJSONLD = await getShapesJSONLD(indexExports.packageExports);
+            console.log(indexExports.packageExports);
+            console.log(shapeJSONLD);
+            console.log(chalk.bold(chalk.green(packageName+'/dist/shapes.json')));
+            return fs.writeFile(path.join('dist', 'shapes.json'), shapeJSONLD);
+        }
+        else
+        {
+            console.warn("Invalid LINCD package. Index file should export a packageExports object. See examples.")
+        }
+
+    } else {
+        console.warn('Not a project');
+    }
+});*/
+var register = function (registryURL) {
+    if (fs_extra_1["default"].existsSync(process.cwd() + '/package.json')) {
+        var pack = JSON.parse(fs_extra_1["default"].readFileSync(process.cwd() + '/package.json', 'utf8'));
+        var version = pack.version;
+        var packageName = pack.name;
+        // let author = pack.author;
+        // let description = pack.description;
+        //
+        // let authorName = pack.author;
+        // if (pack.author.name) {
+        //   authorName = pack.author.name;
+        // }
+        console.log(chalk_1["default"].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: packageName, version: version })
+        })
+            .then(function (res) { return res.json(); })
+            .then(function (json) {
+            if (json.error) {
+                console.log(chalk_1["default"].red('Response: ' + json.error));
+            }
+            else if (json.result) {
+                console.log(chalk_1["default"].blueBright('Response: ') + json.result);
+                if (json.warning) {
+                    console.log(chalk_1["default"].red('Warning: ') + json.warning);
+                }
+            }
+        })["catch"](function (err) {
+            console.warn(chalk_1["default"].red('Warning: ') + 'Could not connect to LINCD registry');
+        });
+    }
+    else {
+        console.warn(chalk_1["default"].red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
+    }
+};
+exports.register = register;
+var buildMetadata = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var app, envVars, updatedPaths, localPackagePaths, metadataFolder, _loop_1, localPackagePaths_1, localPackagePaths_1_1, _a, packageCodeName, packagePath, lincdPackagePath, isAppPackage, e_1_1, packageMetaData, metadataFile;
+    var e_1, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, (0, env_cmd_1.GetEnvVars)({
+                    envFile: {
+                        filePath: '.env-cmdrc.json'
+                    }
+                })];
+            case 1:
+                envVars = _c.sent();
+                if (envVars[process.env.NODE_ENV] && envVars[process.env.NODE_ENV].SITE_ROOT) {
+                    //get the site root of the current environment
+                    app = models_1.NamedNode.getOrCreate(envVars[process.env.NODE_ENV].SITE_ROOT);
+                }
+                else {
+                    warn('Cannot find environment variable SITE_ROOT. Make sure SITE_ROOT is set (likely in .env-cmdrc.json) for the current environment: ' +
+                        process.env.NODE_ENV);
+                    app = models_1.NamedNode.create();
+                }
+                updatedPaths = [];
+                localPackagePaths = getLocalPackagePaths();
+                metadataFolder = path_1["default"].join(process.cwd(), 'data', 'metadata');
+                return [4 /*yield*/, fs_extra_1["default"].ensureDir(metadataFolder)];
+            case 2:
+                _c.sent(); //{recursive:true} but not needed with fs-extra
+                _loop_1 = function (packageCodeName, packagePath, lincdPackagePath, isAppPackage) {
+                    var errors;
+                    return __generator(this, function (_d) {
+                        switch (_d.label) {
+                            case 0:
+                                errors = false;
+                                return [4 /*yield*/, (0, package_metadata_js_1.getPackageMetadata)(packagePath, lincdPackagePath).then(function (response) { return __awaiter(void 0, void 0, void 0, function () {
+                                        var pkg, lincdApp, packageMetaData_1, metadataFile_1;
+                                        return __generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    if (!(response.errors.length > 0)) return [3 /*break*/, 1];
+                                                    // console.log(JSON.stringify(response));
+                                                    warn('Error processing ' + packagePath + ':\n' + response.errors.join('\n'));
+                                                    // throw response
+                                                    errors = true;
+                                                    return [3 /*break*/, 3];
+                                                case 1:
+                                                    pkg = Module_1.Module.getFromURI(response.packageUri);
+                                                    lincdApp = (0, NameSpace_1.createNameSpace)('http://lincd.org/ont/lincd-app/');
+                                                    Prefix_1.Prefix.add('lincdApp', 'http://lincd.org/ont/lincd-app/');
+                                                    if (isAppPackage) {
+                                                        //Note: this needs to match with LincdWebApp.ownPackage accessor;
+                                                        app.overwrite(lincdApp('ownPackage'), pkg.namedNode);
+                                                    }
+                                                    else {
+                                                        //Note: this needs to match with LincdWebApp.packages accessor;
+                                                        app.set(lincdApp('maintainsPackage'), pkg.namedNode);
+                                                    }
+                                                    packageMetaData_1 = JSON.stringify(response.result, null, 2);
+                                                    metadataFile_1 = path_1["default"].join(metadataFolder, packageCodeName + '.json');
+                                                    return [4 /*yield*/, fs_extra_1["default"].writeFile(metadataFile_1, packageMetaData_1).then(function () {
+                                                            updatedPaths.push(metadataFile_1);
+                                                        })];
+                                                case 2:
+                                                    _a.sent();
+                                                    _a.label = 3;
+                                                case 3: return [2 /*return*/];
+                                            }
+                                        });
+                                    }); })];
+                            case 1:
+                                _d.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                };
+                _c.label = 3;
+            case 3:
+                _c.trys.push([3, 8, 9, 10]);
+                localPackagePaths_1 = __values(localPackagePaths), localPackagePaths_1_1 = localPackagePaths_1.next();
+                _c.label = 4;
+            case 4:
+                if (!!localPackagePaths_1_1.done) return [3 /*break*/, 7];
+                _a = __read(localPackagePaths_1_1.value, 4), packageCodeName = _a[0], packagePath = _a[1], lincdPackagePath = _a[2], isAppPackage = _a[3];
+                return [5 /*yield**/, _loop_1(packageCodeName, packagePath, lincdPackagePath, isAppPackage)];
+            case 5:
+                _c.sent();
+                _c.label = 6;
+            case 6:
+                localPackagePaths_1_1 = localPackagePaths_1.next();
+                return [3 /*break*/, 4];
+            case 7: return [3 /*break*/, 10];
+            case 8:
+                e_1_1 = _c.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 10];
+            case 9:
+                try {
+                    if (localPackagePaths_1_1 && !localPackagePaths_1_1.done && (_b = localPackagePaths_1["return"])) _b.call(localPackagePaths_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 10: return [4 /*yield*/, JSONLDWriter_1.JSONLDWriter.stringify(app, process.env.NODE_ENV === 'development')];
+            case 11:
+                packageMetaData = _c.sent();
+                metadataFile = path_1["default"].join(metadataFolder, '_app.json');
+                return [4 /*yield*/, fs_extra_1["default"].writeFile(metadataFile, packageMetaData).then(function () {
+                        updatedPaths.push(metadataFile);
+                    })];
+            case 12:
+                _c.sent();
+                return [2 /*return*/, updatedPaths];
+        }
+    });
+}); };
+exports.buildMetadata = buildMetadata;
+function getLocalPackagePaths() {
+    var packagePaths = [];
+    //add the APP package itself
+    var appPackagePath = process.cwd();
+    var appLincdPackagePath = path_1["default"].join(appPackagePath, 'frontend', 'src', 'package.ts');
+    if (fs_extra_1["default"].existsSync(appPackagePath)) {
+        var packageJSON = (0, utils_1.getPackageJSON)(appPackagePath);
+        packagePaths.push([packageJSON.name, appPackagePath, appLincdPackagePath, true]);
+    }
+    else {
+        console.log('Not a LINCD app');
+    }
+    //NOTE: we could also switch to checking 'workspaces'?
+    var packagesFolder = path_1["default"].join(process.cwd(), 'packages');
+    if (fs_extra_1["default"].existsSync(packagesFolder)) {
+        var localPackages = fs_extra_1["default"].readdirSync(packagesFolder);
+        localPackages.forEach(function (packageFolderName) {
+            packagePaths.push([
+                packageFolderName,
+                path_1["default"].join(packagesFolder, packageFolderName),
+                path_1["default"].join(packagesFolder, packageFolderName, 'lib', 'package.js'),
+            ]);
+        });
+    }
+    return packagePaths;
+}
+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_extra_1["default"].existsSync(path_1["default"].join(packagePath, 'Gruntfile.js'))) {
+            console.warn("No Gruntfile found at ".concat(packagePath, "\\Gruntfile.js. Cannot build."));
+            return;
+        }
+        var nodeEnv = '';
+        if (target == 'production') {
+            if (!(target2 == 'es5' || target2 == 'es6' || typeof target2 == 'undefined')) {
+                console.warn('unknown second build target. Use es5 or es6', target2);
+                return;
+            }
+            var isWindows = /^win/.test(process.platform);
+            if (isWindows) {
+                nodeEnv = 'SET NODE_ENV=production&& ';
+            }
+            else {
+                nodeEnv = "NODE_ENV='production' ";
+            }
+        }
+        if (!target) {
+            target = 'es6';
+        }
+        log('building once: ' +
+            nodeEnv +
+            'grunt build' +
+            (target ? '-' + target : '') +
+            (target2 ? '-' + target2 : '') +
+            ' --color');
+        var method = logResults ? utils_1.execp : utils_1.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: packagePath })["catch"](function (err) {
+            process.exit(1);
+        });
+    }
+    else {
+        console.warn('unknown build target. Use es5, es6 or production.');
+    }
+};
+exports.buildPackage = buildPackage;
+var getLastBuildTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(builds|lib|dist)/**/*.js');
+};
+var getLastModifiedSourceTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(src|data|scss)/**/*', {
+        ignore: [packagePath + '/**/*.scss.json', packagePath + '/**/*.d.ts']
+    });
+};
+var getLastCommitTime = function (packagePath) {
+    // console.log(`git log -1 --format=%ci -- ${packagePath}`);
+    // process.exit();
+    return (0, utils_1.execPromise)("git log -1 --format=%ci -- ".concat(packagePath))
+        .then(function (result) {
+        var lastCommit = new Date(result);
+        // console.log(packagePath,result,lastCommit);
+        return lastCommit;
+    })["catch"](function (_a) {
+        var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+        debugInfo(chalk_1["default"].red('Git error: ') + error.message.toString());
+        return null;
+    });
+};
+var getLastModifiedFile = function (filePath, config) {
+    if (config === void 0) { config = {}; }
+    var files = glob.sync(filePath, config);
+    // console.log(files.join(" - "));
+    var lastModifiedName;
+    var lastModified;
+    var lastModifiedTime = 0;
+    files.forEach(function (fileName) {
+        if (fs_extra_1["default"].lstatSync(fileName).isDirectory()) {
+            // console.log("skipping directory "+fileName);
+            return;
+        }
+        var mtime = fs_extra_1["default"].statSync(path_1["default"].join(fileName)).mtime;
+        var modifiedTime = mtime.getTime();
+        if (modifiedTime > lastModifiedTime) {
+            // console.log(fileName,mtime);
+            lastModifiedName = fileName;
+            lastModified = mtime;
+            lastModifiedTime = modifiedTime;
+        }
+    });
+    return { lastModified: lastModified, lastModifiedName: lastModifiedName, lastModifiedTime: lastModifiedTime };
+};
+var publishUpdated = function (test) {
+    var _this = this;
+    if (test === void 0) { test = false; }
+    var packages = getLocalLincdModules();
+    var browserCoreBuilt = false;
+    var p = Promise.resolve('');
+    var packagesLeft = packages.length;
+    var results = [];
+    log('Checking which packages need to be published by comparing last published date with last git commit');
+    // p = Promise.all(packages.map((pckg) => {
+    packages.forEach(function (pckg) {
+        p = p
+            .then(function (previousResult) {
+            // progressUpdate(packagesLeft-- + ' packages left. Now checking ' + pckg.packageName);
+            // log('# 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());
+            // 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_1["default"].blue('--> is private, skipping'));
+                return chalk_1["default"].gray(pckg.packageName + ' is private');
+                // return previousResult + ' ' + chalk.gray(pckg.packageName + ' is private\n');
+            }
+            return (0, utils_1.execPromise)('npm info ' + pckg.packageName + ' --json')
+                .then(function (output) { return __awaiter(_this, void 0, void 0, function () {
+                var info, lastPublish, lastPublishDate, lastCommit, err_1, res, browserModule;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 3, , 4]);
+                            if (output == '' || output.includes('E404')) {
+                                debugInfo('Empty or 404 response from `npm 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);
+                            }
+                            if (!info) return [3 /*break*/, 2];
+                            lastPublish = void 0;
+                            //yarn:
+                            // let lastPublish = info.data.time[info.data.version];
+                            lastPublish = info.time[info.version];
+                            lastPublishDate = new Date(lastPublish);
+                            return [4 /*yield*/, getLastCommitTime(pckg.path)];
+                        case 1:
+                            lastCommit = _a.sent();
+                            if (!lastCommit) {
+                                shouldPublish = false;
+                                debugInfo('Could not determine last git commit');
+                                // return previousResult + ' ' + chalk.red(pckg.packageName + ' - could not determine last commit\n');
+                                return [2 /*return*/, chalk_1["default"].red(pckg.packageName + ' - could not determine last commit')];
+                            }
+                            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) {
+                                //   log(
+                                //     lastPublishDate.toDateString() +
+                                //     ' ' +
+                                //     lastPublishDate.toTimeString() +
+                                //     ' published ' +
+                                //     info.version,
+                                //   );
+                                //   log(
+                                //     lastCommit.toDateString() + ' ' + new Date(lastCommit).toTimeString() + ' source last committed',
+                                //   );
+                                // }
+                            }
+                            _a.label = 2;
+                        case 2: return [3 /*break*/, 4];
+                        case 3:
+                            err_1 = _a.sent();
+                            // var stats = fs.statSync(path.join(packageDirectory));
+                            // var files = fs.readdirSync(path.join(packageDirectory,'src'));
+                            console.log(chalk_1["default"].red(pckg.packageName + ' failed: ' + err_1.message + '\n'));
+                            console.warn('Returned JSON from npm: ' + output);
+                            // return previousResult + ' ' + chalk.red(pckg.packageName + ' failed: ' + err.message + '\n');
+                            return [2 /*return*/, chalk_1["default"].red(pckg.packageName + ' failed: ' + err_1.message)];
+                        case 4:
+                            if (shouldPublish) {
+                                res = publishPackage(pckg, test, info, version);
+                                if (pckg.packageName == 'browser-core') {
+                                    browserCoreBuilt = true;
+                                }
+                                //when publishing core, also make sure to publish 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, test);
+                                        })];
+                                }
+                                return [2 /*return*/, res];
+                            }
+                            // return previousResult + ' ' + chalk.green(pckg.packageName + ' latest version is up to date\n');
+                            return [2 /*return*/, chalk_1["default"].green(pckg.packageName + ' latest version is up to date')];
+                    }
+                });
+            }); })["catch"](function (_a) {
+                var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                if (error) {
+                    console.log(error.message);
+                }
+                if (stdout) {
+                    console.log(stderr);
+                }
+                if (stderr) {
+                    console.log(stderr);
+                }
+                // return previousResult + ' ' + chalk.red(pckg.packageName + ' failed\n');
+                console.warn(chalk_1["default"].red(pckg.packageName + ' failed'));
+                return chalk_1["default"].red(pckg.packageName + ' failed');
+            });
+        })
+            .then(function (res) {
+            log(res);
+            results.push(res);
+        })["catch"](function (err) {
+            console.warn(chalk_1["default"].red(pckg.packageName + ' failed: ' + err.toString()));
+            results.push(chalk_1["default"].red(pckg.packageName + ' failed: ' + err.toString()));
+        });
+    });
+    return p.then(function () {
+        // if (messages == '')
+        // {
+        //   console.log('All published packages are already up-to-date.');
+        // }
+        // else
+        // {
+        console.log('Summary:                                \n' + results.join('\n'));
+        // }
+    });
+};
+exports.publishUpdated = publishUpdated;
+var publishPackage = function (pkg, test, info, publishVersion) {
+    if (!publishVersion) {
+        // publishVersion = info ? getNextVersion(info.data.version) : '';
+        publishVersion = info ? getNextVersion(info.version) : '';
+    }
+    if (test) {
+        debugInfo('should publish ' + pkg.packageName + ' ' + publishVersion);
+    }
+    else {
+        console.log(chalk_1["default"].blue('publishing ' + pkg.packageName + ' ' + publishVersion));
+    }
+    if (!test) {
+        return (0, utils_1.execPromise)("cd ".concat(pkg.path, " && yarn version ").concat(publishVersion, " && yarn npm publish"), 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 chalk_1["default"].red(pkg.packageName + ' failed\n');
+            }
+            console.log(chalk_1["default"].green('Successfully published ' + pkg.path + ' ' + publishVersion));
+            return chalk_1["default"].green(pkg.packageName + ' published ' + publishVersion + '\n');
+        })["catch"](function (_a) {
+            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+            console.log(chalk_1["default"].red('Failed to publish: ' + error.message));
+            return chalk_1["default"].red(pkg.packageName + ' failed to publish\n');
+        });
+    }
+    else {
+        //when testing what needs to be published
+        return chalk_1["default"].blue(pkg.packageName + ' should publish');
+    }
+};
+var buildUpdated = function (back, target, target2, test) {
+    if (test === void 0) { test = false; }
+    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 = getLocalLincdPackageMap();
+                    jsonldPkgUpdated = needsRebuilding(packages.get('lincd-jsonld'));
+                    cliPkgUpdated = needsRebuilding(packages.get('lincd-cli'));
+                    if (!(jsonldPkgUpdated || cliPkgUpdated)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, utils_1.execPromise)('yarn build-core', false, false, {}, true)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    rebuildAllModules = false;
+                    if (cliPkgUpdated) {
+                        rebuildAllModules = true;
+                        log(chalk_1["default"].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.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.packageName);
+                                needRebuild = needsRebuilding(pkg, true);
+                                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(packageName+' modified since last commit on '+now.toString());
+                                    if (test) {
+                                        debugInfo('Need to build ' + pkg.packageName);
+                                        return [2 /*return*/, chalk_1["default"].blue(pkg.packageName + ' should be build')];
+                                    }
+                                    log('Building ' + pkg.packageName);
+                                    return [2 /*return*/, (0, utils_1.execPromise)('cd ' + pkg.path + ' && yarn build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''))
+                                            .then(function (res) {
+                                            debugInfo(chalk_1["default"].green(pkg.packageName + ' successfully built'));
+                                            return chalk_1["default"].green(pkg.packageName + ' built');
+                                        })["catch"](function (_a) {
+                                            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                                            warn('Failed to build ' + pkg.packageName);
+                                            console.log(stdout);
+                                            var dependentModules = getDependentPackages(dependencies, pkg);
+                                            if (dependentModules.length > 0) {
+                                                // printBuildResults(failedModules, done);
+                                                warn(chalk_1["default"].red(pkg.packageName + ' build failed'));
+                                                warn('Stopping build-updated process because ' +
+                                                    dependentModules.length +
+                                                    ' other packages depend on this package.\n'); //"+dependentModules.map(d => d.packageName).join(", ")));
+                                                process.exit(1);
+                                            }
+                                        })];
+                                }
+                                return [2 /*return*/];
+                            });
+                        }); };
+                    }, function (results) {
+                        if (results.length) {
+                            log('Summary:');
+                            log(results.join('\n'));
+                        }
+                        else {
+                            log(chalk_1["default"].green('Nothing to rebuild'));
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.buildUpdated = buildUpdated;
+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_1["default"].cyan('Last modified source: ' +
+            lastModifiedSource.lastModifiedName +
+            ' on ' +
+            lastModifiedSource.lastModified.toString()));
+        debugInfo(chalk_1["default"].cyan('Last build: ' +
+            (lastModifiedBundle && typeof lastModifiedBundle.lastModified !== 'undefined'
+                ? lastModifiedBundle.lastModified.toString()
+                : 'never')));
+    }
+    return result;
+};
+var printBuildResults = function (failed, done) {
+    log('Successfully built: ' + chalk_1["default"].green(__spreadArray([], __read(done), false).map(function (m) { return m.packageName; }).join(', ')) + '\n');
+    if (failed.length > 0) {
+        warn('Failed to build: ' + chalk_1["default"].red(failed.join(', ')) + '\n');
+    }
+};
+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.packageName) === -1; });
+    }
+    var startFrom;
+    //by default start executing, unless 'from' is given
+    var executing = true;
+    //option to start from a specific pkg in the stack
+    if (filterMethod == 'from') {
+        startFrom = filterValue;
+        if (startFrom) {
+            console.log(chalk_1["default"].blue('Will skip ahead to ' + startFrom));
+        }
+        var seen_1 = false;
+        packages = packages.filter(function (pkg) {
+            if (!seen_1 && (pkg.packageName == startFrom || pkg.packageName == startFrom)) {
+                seen_1 = true;
+            }
+            return seen_1;
+        });
+    }
+    log("Executing '" +
+        chalk_1["default"].blueBright(command) +
+        "' on packages " +
+        chalk_1["default"].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_1["default"].magenta(pkg.packageName));
+            return (0, utils_1.execp)('cd ' + pkg.path + ' && ' + command);
+        });
+    });
+    return p;
+};
+exports.executeCommandForEachPackage = executeCommandForEachPackage;
+var addCapacitor = function (basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(this, void 0, void 0, function () {
+        var targetFolder, pack;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    targetFolder = ensureFolderExists(basePath);
+                    log('Adding capacitor');
+                    fs_extra_1["default"].copySync(path_1["default"].join(__dirname, '..', 'defaults', 'app-static'), targetFolder);
+                    pack = (0, utils_1.getPackageJSON)(basePath);
+                    pack.scripts['build-static'] = 'env-cmd -e static-dev node frontend/scripts/build.js';
+                    fs_extra_1["default"].writeFile(path_1["default"].resolve(basePath, 'package.json'), JSON.stringify(pack));
+                    return [4 /*yield*/, (0, utils_1.execPromise)("yarn add -W -D @capacitor/cli", false, false, null, true)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, utils_1.execPromise)("yarn add -W @capacitor/android @capacitor/core @capacitor/geolocation @capacitor/ios @capacitor/push-notifications", false, false, null, true)];
+                case 2:
+                    _a.sent();
+                    log('Done! Run `yarn build-static` to generate static bundles. Then `yarn cap add android` or `yarn cap add ios`');
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.addCapacitor = addCapacitor;
+var executeCommandForPackage = function (packageName, command) {
+    var packageDetails = getLincdPackages().find(function (modDetails) {
+        return modDetails.packageName.indexOf(packageName) !== -1 || modDetails.packageName.indexOf(packageName) !== -1;
+    });
+    if (packageDetails) {
+        log("Executing 'cd " + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
+        return (0, utils_1.execp)('cd ' + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
+    }
+    else {
+        warn("Could not find a pkg who's name (partially) matched " + chalk_1["default"].cyan(packageName));
+    }
+};
+exports.executeCommandForPackage = executeCommandForPackage;