lincd-cli 1.2.0 → 1.2.2

package/lib/esm/cli-methods.js

@@ -13,10 +13,11 @@ import depcheck from 'depcheck';
 import { getEnvFile } from 'env-cmd/dist/get-env-vars.js';
 import fs from 'fs-extra';
 import path, { dirname } from 'path';
-import { debugInfo, execp, execPromise, getFileImports, getFiles, getLastCommitTime, getPackageJSON, isValidLINCDImport, needsRebuilding, } from './utils.js';
+import { debugInfo, execp, execPromise, getFileImports, getFiles, getLastCommitTime, getPackageJSON, isImportOutsideOfPackage, isImportWithMissingExtension, isInvalidLINCDImport, needsRebuilding, } from './utils.js';
 import { statSync } from 'fs';
 import { findNearestPackageJson } from 'find-nearest-package-json';
 import { LinkedFileStorage } from 'lincd/utils/LinkedFileStorage';
+import { spawn as spawnChild } from 'child_process';
 // import pkg from 'lincd/utils/LinkedFileStorage';
 // const { LinkedFileStorage } = pkg;
 // const config = require('lincd-server/site.webpack.config');
@@ -24,8 +25,10 @@ import { glob } from 'glob';
 import webpack from 'webpack';
 import stagedGitFiles from 'staged-git-files';
 import ora from 'ora';
+//@ts-ignore
+let dirname__ = typeof __dirname !== 'undefined' ? __dirname : dirname(import.meta.url).replace('file:/', '');
 var variables = {};
-export const createApp = (name, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createApp = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     if (!name) {
         console.warn('Please provide a name as the first argument');
     }
@@ -34,7 +37,7 @@ export const createApp = (name, basePath = process.cwd()) => __awaiter(void 0, v
     if (!fs.existsSync(targetFolder)) {
         fs.mkdirSync(targetFolder);
     }
-    fs.copySync(path.join(__dirname, '..', 'defaults', 'app-with-backend'), targetFolder);
+    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'app-with-backend'), targetFolder);
     //make sure the data folder exists (even though its empty).. copying empty folders does not work with fs.copySync
     fs.mkdirSync(path.join(targetFolder, 'data'), { recursive: true });
     fs.mkdirSync(path.join(targetFolder, 'data/uploads/resized'), {
@@ -138,7 +141,7 @@ function checkPackagePath(rootPath, packagePath, res) {
         }
     }
 }
-function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd, sync = false) {
+export function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd, sync = false) {
     let dependencies = new Map();
     //get dependencies of each package
     let leastDependentPackage;
@@ -605,7 +608,7 @@ const camelCase = (str) => {
     }
     return str;
 };
-export const createOntology = (prefix, uriBase, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createOntology = (prefix_1, uriBase_1, ...args_1) => __awaiter(void 0, [prefix_1, uriBase_1, ...args_1], void 0, function* (prefix, uriBase, basePath = process.cwd()) {
     if (!prefix) {
         console.warn('Please provide a suggested prefix as the first argument');
         return;
@@ -620,18 +623,18 @@ export const createOntology = (prefix, uriBase, basePath = process.cwd()) => __a
     //copy ontology accessor file
     log('Creating files for ontology \'' + prefix + '\'');
     let targetFile = path.join(targetFolder, hyphenName + '.ts');
-    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+    fs.copySync(path.join(dirname__, '..', '..', 'defaults', 'package', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
     //copy data files
     let targetDataFile = path.join(targetFolder, '..', 'data', hyphenName + '.json');
     let targetDataFile2 = path.join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
-    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);
+    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);
     yield replaceVariablesInFiles(targetFile, targetDataFile, targetDataFile2);
     log(`Prepared a new ontology data files in ${chalk.magenta(targetDataFile.replace(basePath, ''))}`, `And an ontology accessor file in ${chalk.magenta(targetFile.replace(basePath, ''))}`);
     //if this is not a lincd app (but a lincd package instead)
     if (!sourceFolder.includes('frontend')) {
         //then also add an import to index
-        let indexPath = addLineToIndex(`import './ontologies/${hyphenName}';`, 'ontologies');
+        let indexPath = addLineToIndex(`import './ontologies/${hyphenName}.js';`, 'ontologies');
         log(`Added an import of this file from ${chalk.magenta(indexPath)}`);
     }
 });
@@ -755,17 +758,20 @@ function getSourceFolder(basePath = process.cwd()) {
  * get __dirname for either ESM/CJS
  */
 export const getScriptDir = () => {
-    // @ts-ignore
-    if (typeof __dirname !== 'undefined') {
-        // @ts-ignore
-        return __dirname;
-    }
-    else {
-        // @ts-ignore
-        return dirname(import.meta.url).replace('file:/', '');
-    }
+    return dirname__;
+    // // @ts-ignore
+    // if (typeof __dirname !== 'undefined')
+    // {
+    //   // @ts-ignore
+    //   return __dirname;
+    // }
+    // else
+    // {
+    //   // @ts-ignore
+    //   return dirname(import.meta.url).replace('file:/','');
+    // }
 };
-export const createShape = (name, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createShape = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
     let targetFolder = ensureFolderExists(sourceFolder, 'shapes');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
@@ -779,11 +785,11 @@ export const createShape = (name, basePath = process.cwd()) => __awaiter(void 0,
     //if this is NOT a lincd app (but a lincd package)
     let indexPath;
     if (!sourceFolder.includes('frontend')) {
-        indexPath = addLineToIndex(`import './shapes/${hyphenName}';`, 'shapes');
+        indexPath = addLineToIndex(`import './shapes/${hyphenName}.js';`, 'shapes');
         log(`Added an import of this file from ${chalk.magenta(indexPath)}`);
     }
 });
-export const createSetComponent = (name, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createSetComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     let targetFolder = ensureFolderExists(basePath, 'src', 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
     //copy default shape file
@@ -794,10 +800,10 @@ export const createSetComponent = (name, basePath = process.cwd()) => __awaiter(
     fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'component.scss'), targetFile2);
     //replace variables in some of the copied files
     yield replaceVariablesInFiles(targetFile, targetFile2);
-    let indexPath = addLineToIndex(`import './components/${hyphenName}';`, 'components');
+    let indexPath = addLineToIndex(`import './components/${hyphenName}.js';`, 'components');
     log(`Created a new set component in ${chalk.magenta(targetFile.replace(basePath, ''))}`, `Created a new stylesheet in ${chalk.magenta(targetFile2.replace(basePath, ''))}`, `Added an import of this file from ${chalk.magenta(indexPath)}`);
 });
-export const createComponent = (name, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createComponent = (name_1, ...args_1) => __awaiter(void 0, [name_1, ...args_1], void 0, function* (name, basePath = process.cwd()) {
     let sourceFolder = getSourceFolder(basePath);
     let targetFolder = ensureFolderExists(sourceFolder, 'components');
     let { hyphenName, camelCaseName, underscoreName } = setNameVariables(name);
@@ -813,15 +819,15 @@ export const createComponent = (name, basePath = process.cwd()) => __awaiter(voi
     //if this is not a lincd app (but a lincd package instead)
     if (!sourceFolder.includes('frontend')) {
         //then also add an import to index
-        let indexPath = addLineToIndex(`import './components/${hyphenName}';`, 'components');
+        let indexPath = addLineToIndex(`import './components/${hyphenName}.js';`, 'components');
         log(`Added an import of this file from ${chalk.magenta(indexPath)}`);
     }
 });
 //read the source of all ts/tsx files in the src folder
 //if there is an import that imports a lincd package with /src/ in it, then warn
-//if there is an import that imports outside of the src folder, then warn
-export const checkImports = (sourceFolder = getSourceFolder(), depth = 0, // Used to check if the import is outside of the src folder
-invalidImports = new Map()) => __awaiter(void 0, void 0, void 0, function* () {
+//if there is an import that imports something from outside the src folder, then warn
+export const checkImports = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (sourceFolder = getSourceFolder(), depth = 0, // Used to check if the import is outside the src folder
+invalidImports = new Map()) {
     const dir = fs.readdirSync(sourceFolder);
     // Start checking each file in the source folder
     for (const file of dir) {
@@ -830,40 +836,66 @@ invalidImports = new Map()) => __awaiter(void 0, void 0, void 0, function* () {
         // INFO: For future use - if this part fails, it could be due to user permissions
         //  i.e. the program not having access to check the file metadata
         if (!filename.match(/\.tsx?$/)) {
-            if (statSync(filename).isDirectory()) {
-                yield checkImports(filename, depth + 1, invalidImports);
+            try {
+                if (statSync(filename).isDirectory()) {
+                    yield checkImports(filename, depth + 1, invalidImports);
+                }
+                else {
+                    // Ignore all files that aren't one of the following:
+                    // - .ts
+                    // - .tsx
+                    continue;
+                }
+            }
+            catch (e) {
+                console.log(e);
             }
-            // Ignore all files that aren't one of the following:
-            // - .ts
-            // - .tsx
-            continue;
         }
         const allImports = yield getFileImports(filename);
-        const lincdImports = allImports.filter((i) => i.includes('lincd') || i.includes('..'));
-        lincdImports.forEach((i) => {
-            if (!isValidLINCDImport(i, depth)) {
-                if (!invalidImports.has(filename)) {
-                    invalidImports.set(filename, []);
-                }
-                invalidImports.get(filename).push(i);
+        if (!invalidImports.has(filename)) {
+            invalidImports.set(filename, []);
+        }
+        allImports.forEach((i) => {
+            if (isImportOutsideOfPackage(i, depth)) {
+                invalidImports.get(filename).push({
+                    type: 'outside_package',
+                    importPath: i,
+                });
+            }
+            if (isInvalidLINCDImport(i, depth)) {
+                invalidImports.get(filename).push({
+                    type: 'lincd',
+                    importPath: i,
+                });
+            }
+            if (isImportWithMissingExtension(i)) {
+                invalidImports.get(filename).push({
+                    type: 'missing_extension',
+                    importPath: i,
+                });
             }
         });
     }
     let res = '';
+    //check if invalidImports has any
+    let flat = [...invalidImports.values()].flat();
     // All recursion must have finished, display any errors
-    if (depth === 0 && invalidImports.size > 0) {
+    if (depth === 0 && flat.length > 0) {
         res += chalk.red('Invalid imports found.\n');
         invalidImports.forEach((value, key) => {
             // res += '- '+chalk.blueBright(key.split('/').pop()) + ':\n';
-            value.forEach((i) => {
-                res += chalk.red(key.split('/').pop() + ' imports from \'' + i + '\'\n');
-                if (i.indexOf('../../') === 0) {
-                    res +=
-                        'To fix: import from the NPM package directly.\n';
+            value.forEach(({ type, importPath }) => {
+                let message = key.split('/').pop() + ' imports from \'' + importPath + '\'';
+                if (type === 'outside_package') {
+                    message += ' which is outside the package source root';
                 }
-                else if ('/src/') {
-                    res += 'To fix: you likely need to replace /src with /lib\n';
+                if (type === 'lincd') {
+                    message += ' which should not contain /src/ or /lib/ in the import path';
                 }
+                if (type === 'missing_extension') {
+                    message += ' which should end with a file extension. Like .js or .scss';
+                }
+                res += chalk.red(message + '\n');
             });
         });
         throw res;
@@ -898,7 +930,7 @@ export const depCheckStaged = () => __awaiter(void 0, void 0, void 0, function*
         });
     });
 });
-export const depCheck = (packagePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const depCheck = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
     return new Promise((resolve, reject) => {
         depcheck(packagePath, {}, (results) => {
             if (results.missing) {
@@ -918,7 +950,10 @@ export const depCheck = (packagePath = process.cwd()) => __awaiter(void 0, void
                 if (missingLincdPackages.length > 0) {
                     reject(chalk.red(packagePath.split('/').pop() +
                         '\n[ERROR] These LINCD packages are imported but they are not listed in package.json:\n- ' +
-                        missingLincdPackages.join(',\n- ')));
+                        missingLincdPackages.map(missedKey => {
+                            const files = results.missing[missedKey];
+                            return `${missedKey} (${files.length} files: ${files.join(', ')})`;
+                        }).join(',\n- ')));
                 }
                 else if (missing.length > 0) {
                     resolve(chalk.redBright('warning: ' + packagePath.split('/').pop() +
@@ -985,9 +1020,80 @@ export const ensureEnvironmentLoaded = () => __awaiter(void 0, void 0, void 0, f
         }
     }
 });
-export const startServer = (initOnly = false, ServerClass = null) => __awaiter(void 0, void 0, void 0, function* () {
+export const runMethod = (packageName, method, options) => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
-    let lincdConfig = yield import(path.join(process.cwd(), 'lincd.config.js'));
+    if (options.spawn) {
+        let lincdConfig = (yield import(path.join(process.cwd(), 'lincd.config.js'))).default;
+        //@ts-ignore
+        const ServerClass = (yield import('lincd-server/shapes/LincdServer')).LincdServer;
+        yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
+        let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () { return (yield import(path.join(process.cwd(), 'src', 'App'))).default; }) }, lincdConfig));
+        //init the server
+        console.log('Initializing server...');
+        server.initOnly().then(() => {
+            //process the backend method call
+            console.log('Running method ' + method);
+            //mock the request and response objects
+            let request = {
+                body: {},
+                query: {},
+                params: {},
+                headers: {},
+                method: 'POST',
+                url: '/' + packageName + '/' + method,
+            };
+            let response = {
+                status: (statusCode) => {
+                    console.log('Response status code:', statusCode);
+                    return response;
+                },
+                json: (data) => {
+                    console.log('Response data:', data);
+                },
+                send: (data) => {
+                    console.log('Response data:', data);
+                },
+            };
+            //TODO; allow sending args
+            server.callBackendMethod(packageName, method, [], request, response).then(() => {
+                console.log('Done');
+                process.exit();
+            });
+        });
+    }
+    else {
+        //reuse the existing running LincdServer instance.
+        //make a HTTP call
+        //'/call/:pkg/:method',
+        fetch(process.env.SITE_ROOT + '/call/' + packageName + '/' + method, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        }).then((response) => {
+            if (!response.ok) {
+                throw new Error('Network response was not ok');
+            }
+            return response.json();
+        }).then((data) => {
+            console.log('Response data:', data);
+            process.exit();
+        }).catch((error) => {
+            var _a;
+            if (error.code === 'ECONNREFUSED' || ((_a = error.cause) === null || _a === void 0 ? void 0 : _a.code) === 'ECONNREFUSED') {
+                console.error(chalk.red('Could not connect to the backend server. Is it running?'));
+                console.error(`Make sure you ${chalk.magenta('run "yarn start" in a separate process')} before calling this method.`);
+            }
+            else {
+                console.error('Error during backend call:', error);
+            }
+            process.exit(1);
+        });
+    }
+});
+export const startServer = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (initOnly = false, ServerClass = null) {
+    yield ensureEnvironmentLoaded();
+    let lincdConfig = (yield import(path.join(process.cwd(), 'lincd.config.js'))).default;
     // function scssLoadcall(source, filename) {
     //   return 'console.log("SCSS CALL: ' + filename + '");\n' + source;
     //   process.exit();
@@ -1003,7 +1109,16 @@ export const startServer = (initOnly = false, ServerClass = null) => __awaiter(v
         ServerClass = (yield import('lincd-server/shapes/LincdServer')).LincdServer;
     }
     yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
-    let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () { return (yield import(path.join(process.cwd(), 'src', 'App'))).default; }) }, lincdConfig));
+    let appPromise;
+    if (process.env.NODE_ENV !== 'development') {
+        appPromise = (yield import(path.join(process.cwd(), 'lib', 'App.js'))).default;
+    }
+    else {
+        appPromise = (yield import(path.join(process.cwd(), 'src', 'App.js'))).default;
+    }
+    let server = new ServerClass(Object.assign({ loadAppComponent: () => __awaiter(void 0, void 0, void 0, function* () {
+            return appPromise;
+        }) }, lincdConfig));
     //Important to use slice, because when using clusers, child processes need to be able to read the same arguments
     let args = process.argv.slice(2);
     //if --initOnly is passed, only initialize the server and don't start it
@@ -1015,10 +1130,15 @@ export const startServer = (initOnly = false, ServerClass = null) => __awaiter(v
     }
 });
 export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield buildFrontend();
+    yield buildBackend();
+    console.log(chalk.magenta(`✅ ${process.env.NODE_ENV} app build finished`));
+});
+export const buildFrontend = () => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
     const webpackAppConfig = yield (yield import('./config-webpack-app.js')).getWebpackAppConfig();
-    console.log(chalk.magenta(`Building ${process.env.NODE_ENV} app bundles`));
-    return new Promise((resolve, reject) => {
+    console.log(chalk.magenta(`🛠 Building ${process.env.NODE_ENV} frontend bundles`));
+    yield new Promise((resolve, reject) => {
         webpack(webpackAppConfig, (err, stats) => __awaiter(void 0, void 0, void 0, function* () {
             if (err) {
                 console.error(err.stack || err);
@@ -1056,11 +1176,13 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
         // and if we want to upload to storage, we need set S3_BUCKET_ENDPOINT
         if (process.env.NODE_ENV === 'development' || !process.env.S3_BUCKET_ENDPOINT) {
             console.warn('Upload build to storage skip in development environment or S3_BUCKET_ENDPOINT is not set');
-            process.exit();
+            return;
+            // process.exit();
         }
         if (process.env.APP_ENV) {
             console.warn('Not uploading to CDN for app builds');
-            process.exit();
+            return;
+            // process.exit();
         }
         // load the storage config
         const storageConfig = yield import(path.join(process.cwd(), 'scripts', 'storage-config.js'));
@@ -1076,6 +1198,12 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
             }
             // get all files in the web directory and then upload them to the storage
             const files = yield getFiles(pathDir);
+            console.log(chalk.magenta(`🕊  Publishing ${files.length} public files to linked file storage`));
+            const clearSpinner = ora({
+                discardStdin: true,
+                text: `Publishing ${files.length} public files`,
+            }).start();
+            let counter = 0;
             const uploads = files.map((filePath) => __awaiter(void 0, void 0, void 0, function* () {
                 // read file content
                 const fileContent = yield fs.promises.readFile(filePath);
@@ -1083,14 +1211,75 @@ export const buildApp = () => __awaiter(void 0, void 0, void 0, function* () {
                 // example: /Users/username/project/www/index.html -> /project/www/index.html
                 const pathname = filePath.replace(pathDir, `/${rootDirectory}`);
                 // upload file to storage
-                return yield LinkedFileStorage.saveFile(pathname, fileContent);
+                yield LinkedFileStorage.saveFile(pathname, fileContent).then(() => {
+                    clearSpinner.text = `${counter++}/${files.length}: - Published ${pathname} `;
+                }).catch(console.error);
             }));
             const urls = yield Promise.all(uploads);
-            console.log(`${urls.length} files uploaded to storage`);
-            process.exit();
+            clearSpinner.succeed(`${urls.length} files uploaded to storage`);
         }
     }));
 });
+export const buildBackend = () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(chalk.magenta(`🛠 Preparing ${process.env.NODE_ENV} backend`));
+    //run tsc in the backend folder
+    yield ensureEnvironmentLoaded();
+    const sourceFolder = path.join(process.cwd(), 'src');
+    const targetFolder = path.join(process.cwd(), 'lib');
+    // Step 1: Clear lib folder
+    const clearSpinner = ora({
+        discardStdin: true,
+        text: 'Clearing lib folder',
+    }).start();
+    try {
+        if (fs.existsSync(targetFolder)) {
+            yield fs.remove(targetFolder);
+        }
+        clearSpinner.succeed('Lib folder cleared');
+    }
+    catch (e) {
+        console.error(e);
+        clearSpinner.fail('Failed to clear lib folder');
+        return;
+    }
+    // Step 2: Compile TS files
+    const compileSpinner = ora({
+        discardStdin: true,
+        text: 'Compiling backend TS files',
+    }).start();
+    try {
+        yield execPromise(`yarn exec tsc`);
+        compileSpinner.succeed('Backend TS files compiled');
+    }
+    catch (e) {
+        console.error(e);
+        compileSpinner.fail('Failed to compile backend TS files');
+        return;
+    }
+    // Step 3: Copy CSS files
+    const copySpinner = ora({
+        discardStdin: true,
+        text: 'Copying CSS files',
+    }).start();
+    try {
+        const cssFiles = yield getFiles(sourceFolder, '.css');
+        yield Promise.all(cssFiles.map((file) => {
+            const targetFile = file.replace(sourceFolder, targetFolder);
+            //ensure the target folder exists
+            const targetDir = path.dirname(targetFile);
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            return fs.copyFile(file, targetFile);
+        }));
+        copySpinner.succeed(`${cssFiles.length} CSS files copied`);
+    }
+    catch (e) {
+        console.error(e);
+        copySpinner.fail('Failed to copy CSS files');
+    }
+    return true;
+});
 export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function* () {
     yield ensureEnvironmentLoaded();
     // let packages = getLincdPackages();
@@ -1233,7 +1422,7 @@ export const upgradePackages = () => __awaiter(void 0, void 0, void 0, function*
     // })
     // });
 });
-export const createPackage = (name, uriBase, basePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const createPackage = (name_1, uriBase_1, ...args_1) => __awaiter(void 0, [name_1, uriBase_1, ...args_1], void 0, function* (name, uriBase, basePath = process.cwd()) {
     if (!name) {
         console.warn('Please provide a name as the first argument');
         return;
@@ -1366,31 +1555,36 @@ export const register = function (registryURL) {
         console.warn(chalk.red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
     }
 };
-export const buildPackage = (target, target2, packagePath = process.cwd(), logResults = true) => __awaiter(void 0, void 0, void 0, function* () {
+export const buildPackage = (target_1, target2_1, ...args_1) => __awaiter(void 0, [target_1, target2_1, ...args_1], void 0, function* (target, target2, packagePath = process.cwd(), logResults = true) {
     let spinner;
     if (logResults) {
         //TODO: replace with listr so we can show multiple processes at once
         spinner = ora({
             discardStdin: true,
-            text: 'Compiling code',
+            text: 'Compiling ESM',
         }).start();
     }
     let buildProcess = Promise.resolve(true);
     let buildStep = (step) => {
         buildProcess = buildProcess.then((previousResult) => {
+            if (!previousResult) {
+                return false;
+            }
             if (logResults) {
                 spinner.text = step.name;
                 spinner.start();
             }
             return step.apply().then(stepResult => {
+                //if a build step returns a string,
+                //a warning is shown but the build is still successful with warnings
                 if (typeof stepResult === 'string') {
                     // spinner.text = step.name + ' - ' + stepResult;
                     if (logResults) {
                         spinner.warn(step.name + ' - ' + stepResult);
                         spinner.stop();
                     }
-                    //warning is shown, but build is still succesful with warnings
-                    return false;
+                    //can still continue
+                    return true;
                 }
                 else if (stepResult === true || typeof stepResult === 'undefined') {
                     if (logResults) {
@@ -1398,13 +1592,31 @@ export const buildPackage = (target, target2, packagePath = process.cwd(), logRe
                     }
                     return previousResult && true;
                 }
+                else if (typeof stepResult === 'object' && stepResult.error) {
+                    if (logResults) {
+                        spinner.fail(step.name + ' - ' + stepResult.error);
+                        spinner.stop();
+                    }
+                    //failed and should stop
+                    return false;
+                }
             });
         });
     };
     buildStep({
-        name: 'Compiling code',
+        name: 'Checking imports',
+        apply: () => checkImports(packagePath + '/src'),
+    });
+    buildStep({
+        name: 'Compiling ESM',
+        apply: () => __awaiter(void 0, void 0, void 0, function* () {
+            return compilePackageESM(packagePath);
+        }),
+    });
+    buildStep({
+        name: 'Compiling CJS',
         apply: () => __awaiter(void 0, void 0, void 0, function* () {
-            return compilePackage(packagePath);
+            return compilePackageCJS(packagePath);
         }),
     });
     buildStep({
@@ -1441,29 +1653,26 @@ export const buildPackage = (target, target2, packagePath = process.cwd(), logRe
             return removeOldFiles(packagePath);
         }),
     });
-    buildStep({
-        name: 'Checking imports',
-        apply: () => checkImports(packagePath),
-    });
     buildStep({
         name: 'Checking dependencies',
         apply: () => depCheck(packagePath),
     });
     let success = yield buildProcess.catch(err => {
-        let msg = err.error ? err.error : err.stdout + '\n' + err.stderr;
+        let msg = typeof err === 'string' || err instanceof Error ? err.toString() : (err.error && !err.error.toString().includes('Command failed:') ? err.error : err.stdout + '\n' + err.stderr);
         if (logResults) {
             spinner.stopAndPersist({
                 symbol: chalk.red('✖'),
-                text: 'Build failed',
+                // text: 'Build failed',
             });
         }
         else {
             console.log(chalk.red(packagePath.split('/').pop(), ' - Build failed:'));
+            console.log(err);
         }
         console.log(msg);
     });
     //will be undefined if there was an error
-    if (typeof success !== 'undefined') {
+    if (typeof success !== 'undefined' && success !== false) {
         if (logResults) {
             spinner.stopAndPersist({
                 symbol: chalk.greenBright('✔'),
@@ -1471,31 +1680,57 @@ export const buildPackage = (target, target2, packagePath = process.cwd(), logRe
             });
         }
     }
+    else {
+        spinner.stopAndPersist({
+            symbol: chalk.red('✖'),
+            text: 'Build failed',
+        });
+    }
     return success;
 });
-export const compilePackage = (packagePath = process.cwd()) => __awaiter(void 0, void 0, void 0, function* () {
+export const compilePackage = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
     //echo 'compiling CJS' && tsc -p tsconfig-cjs.json && echo 'compiling ESM' && tsc -p tsconfig-esm.json
-    let cjsConfig = fs.existsSync(path.join(packagePath, 'tsconfig-cjs.json'));
-    let esmConfig = fs.existsSync(path.join(packagePath, 'tsconfig-esm.json'));
-    let compileCJS = `yarn exec tsc -p tsconfig-cjs.json`;
-    let compileESM = `yarn exec tsc -p tsconfig-esm.json`;
-    let compileCommand;
-    if (cjsConfig && esmConfig) {
-        compileCommand = `${compileCJS} && ${compileESM}`;
-    }
-    else if (cjsConfig) {
-        compileCommand = compileCJS;
-    }
-    else if (esmConfig) {
-        compileCommand = compileESM;
-    }
-    else {
-        compileCommand = `yarn exec tsc`;
-    }
+    // let cjsConfig = fs.existsSync(path.join(packagePath,'tsconfig-cjs.json'));
+    // let esmConfig = fs.existsSync(path.join(packagePath,'tsconfig-esm.json'));
+    // let compileCJS = `yarn exec tsc -p tsconfig-cjs.json`;
+    // let compileESM = `yarn exec tsc -p tsconfig-esm.json`;
+    // let compileCommand;
+    // if (cjsConfig && esmConfig)
+    // {
+    //   compileCommand = `${compileCJS} && ${compileESM}`;
+    // }
+    // else if (cjsConfig)
+    // {
+    //   compileCommand = compileCJS;
+    // }
+    // else if (esmConfig)
+    // {
+    //   compileCommand = compileESM;
+    // }
+    // else
+    // {
+    //   compileCommand = `yarn exec tsc`;
+    // }
+    yield compilePackageESM(packagePath);
+    yield compilePackageCJS(packagePath);
+});
+export const compilePackageESM = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+    //echo 'compiling CJS' && tsc -p tsconfig-cjs.json && echo 'compiling ESM' && tsc -p tsconfig-esm.json
+    let compileCommand = `yarn exec tsc -p tsconfig-esm.json`;
     return execPromise(compileCommand, false, false, { cwd: packagePath }).then(res => {
         return res === '';
     });
 });
+export const compilePackageCJS = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (packagePath = process.cwd()) {
+    let compileCommand = `yarn exec tsc -p tsconfig-cjs.json`;
+    return execPromise(compileCommand, false, false, { cwd: packagePath }).then(res => {
+        return res === '';
+    }).catch(err => {
+        return {
+            error: err.stdout,
+        };
+    });
+});
 export var publishUpdated = function (test = false) {
     let packages = getLocalLincdModules();
     var p = Promise.resolve('');
@@ -1640,8 +1875,8 @@ export var publishUpdated = function (test = false) {
         // }
     });
 };
-function getEnvJsonPath(relativeToPath = process.cwd()) {
-    return __awaiter(this, void 0, void 0, function* () {
+function getEnvJsonPath() {
+    return __awaiter(this, arguments, void 0, function* (relativeToPath = process.cwd()) {
         let path = '';
         if (!relativeToPath.endsWith('/')) {
             relativeToPath += '/';
@@ -1703,8 +1938,8 @@ export var publishPackage = function (pkg, test, info, publishVersion) {
         });
     });
 };
-export var buildUpdated = function (back, target, target2, useGitForLastModified = false, test = false) {
-    return __awaiter(this, void 0, void 0, function* () {
+export var buildUpdated = function (back_1, target_1, target2_1) {
+    return __awaiter(this, arguments, void 0, function* (back, target, target2, useGitForLastModified = false, test = false) {
         // back = back || 1;
         // return execPromise(`git log -${back} --format=%ci`).then((result) => {
         // let now = new Date();
@@ -1715,16 +1950,26 @@ export var buildUpdated = function (back, target, target2, useGitForLastModified
         // let packages = getLocalLincdModules();
         let packages = getLocalLincdPackageMap();
         // console.log(packages);
-        let jsonldPkgUpdated = yield needsRebuilding(packages.get('lincd-jsonld'), useGitForLastModified);
+        // let jsonldPkgUpdated = await needsRebuilding(
+        //   packages.get('lincd-jsonld'),
+        //   useGitForLastModified,
+        // );
         // let cliPkgUpdated = await needsRebuilding(packages.get('lincd-cli'), useGitForLastModified);
         //if either cli or jsonldPkg needs to be rebuilt
         // if (jsonldPkgUpdated || cliPkgUpdated) {
-        if (jsonldPkgUpdated) {
-            yield execPromise('yarn exec tsc && echo "compiled lincd-jsonld"', false, false, {
-                cwd: packages.get('lincd-jsonld').path,
-            }, true);
-            // await execPromise('yarn build-core', false, false, {}, true);
-        }
+        // if (jsonldPkgUpdated)
+        // {
+        //   await execPromise(
+        //     'yarn exec tsc && echo "compiled lincd-jsonld"',
+        //     false,
+        //     false,
+        //     {
+        //       cwd: packages.get('lincd-jsonld').path,
+        //     },
+        //     true,
+        //   );
+        //   // await execPromise('yarn build-core', false, false, {}, true);
+        // }
         let rebuildAllModules = false;
         // if (cliPkgUpdated) {
         //   rebuildAllModules = true;
@@ -1738,9 +1983,10 @@ export var buildUpdated = function (back, target, target2, useGitForLastModified
             return (pkg) => __awaiter(this, void 0, void 0, function* () {
                 // debugInfo('# Checking package ' + pkg.packageName);
                 let needRebuild = yield needsRebuilding(pkg, useGitForLastModified);
-                if (pkg.packageName === 'lincd-jsonld' && jsonldPkgUpdated) {
-                    needRebuild = true;
-                }
+                // if (pkg.packageName === 'lincd-jsonld' && jsonldPkgUpdated)
+                // {
+                //   needRebuild = true;
+                // }
                 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());
@@ -1856,8 +2102,8 @@ export var addLinesToFile = function (filePath, entries) {
     });
     fs.writeFileSync(filePath, fileContents);
 };
-export var addCapacitor = function (basePath = process.cwd()) {
-    return __awaiter(this, void 0, void 0, function* () {
+export var addCapacitor = function () {
+    return __awaiter(this, arguments, void 0, function* (basePath = process.cwd()) {
         let targetFolder = ensureFolderExists(basePath);
         log('Adding capacitor');
         fs.copySync(path.join(getScriptDir(), '..', '..', 'defaults', 'app-static'), targetFolder);
@@ -1918,13 +2164,14 @@ export var executeCommandForPackage = function (packageName, command) {
     if (packageDetails) {
         log('Executing \'cd ' +
             packageDetails.path +
-            ' && yarn exec lincd' +
+            ' && yarn lincd' +
             (command ? ' ' + command : '') +
             '\'');
-        return execp('cd ' +
-            packageDetails.path +
-            ' && yarn exec lincd' +
-            (command ? ' ' + command : ''));
+        spawnChild(process.platform === 'win32' ? 'yarn.cmd' : 'yarn', // Windows quirk
+        ['lincd', command || null], {
+            cwd: packageDetails.path,
+            stdio: 'inherit',
+        });
     }
     else {
         warn('Could not find a pkg who\'s name (partially) matched ' +