leanweb 1.0.4

package/commands/build.js

@@ -0,0 +1,160 @@
+(async () => {
+   const fs = require('fs');
+   const path = require('path');
+   const fse = require('fs-extra');
+   const utils = require('./utils.js');
+   const parser = require('../lib/lw-html-parser.js');
+
+   let env;
+   const args = process.argv;
+   if (args.length >= 3) {
+      env = args[2];
+   }
+
+   const replaceNodeModulesImport = (str, filePath) => {
+      // match import not starting with dot or slash
+      return str.replace(/^(\s*import.+?['"])([^\.|\/].+?)(['"].*)$/gm, (m, a, b, c) => {
+         if (b.startsWith(`~`)) {
+            // ~/package.json
+            return a + path.normalize(`${process.cwd()}/` + b.substring(1)) + c;
+         } else if (b.indexOf('/') > -1) {
+            // lodash-es/get.js
+            return a + path.normalize(`${process.cwd()}/node_modules/` + b) + c;
+         } else {
+            const nodeModulePath = `${process.cwd()}/node_modules/` + b + '/package.json';
+            const package = require(nodeModulePath);
+            // lodash-es
+            return a + path.normalize(`${process.cwd()}/node_modules/` + b + '/' + package.main) + c;
+         }
+      });
+   };
+
+   const walkDirSync = (dir, accept = null, callback) => {
+      fs.readdirSync(dir).forEach(f => {
+         let dirPath = path.join(dir, f);
+         const isDirectory = fs.statSync(dirPath).isDirectory() && (!accept || (typeof accept === 'function' && accept(dirPath, f)));
+         isDirectory ? walkDirSync(dirPath, accept, callback) : callback(path.join(dirPath));
+      });
+   };
+
+   const preprocessJsImport = filePath => {
+      if (filePath.toLowerCase().endsWith('.js') && !filePath.toLowerCase().endsWith('/ast.js') && !filePath.startsWith(`${utils.dirs.build}/lib/`)) {
+         let jsFileString = fs.readFileSync(filePath, 'utf8');
+         jsFileString = replaceNodeModulesImport(jsFileString, filePath);
+         fs.writeFileSync(filePath, jsFileString);
+      }
+   };
+
+   const buildDirFilter = dirPath => {
+      if (dirPath.startsWith(`${utils.dirs.build}/lib/`)) {
+         return false;
+      }
+      return true;
+   };
+
+   const leanwebPackageJSON = require(`${__dirname}/../package.json`);
+
+   const buildModule = (projectPath) => {
+
+      const project = require(`${projectPath}/${utils.dirs.src}/leanweb.json`);
+      const isMain = process.cwd() === projectPath;
+
+      const buildDir = isMain ? utils.dirs.build : `${utils.dirs.build}/_dependencies/${project.name}`;
+      fs.mkdirSync(buildDir, { recursive: true });
+
+      let depImports = '';
+      project.imports?.forEach(im => {
+         let depPath;
+         if (im.indexOf('/') < 0) {
+            depPath = `${process.cwd()}/node_modules/${im}`;
+         } else {
+            if (im.startsWith('./')) {
+               depPath = `${process.cwd()}/${im}`;
+            } else if (im.startsWith('/')) {
+               depPath = im;
+            } else {
+               depPath = `${process.cwd()}/node_modules/${im}`;
+            }
+         }
+         const depName = buildModule(depPath);
+         if (isMain) {
+            depImports += `import './_dependencies/${depName}/${depName}.js';\n`;
+         } else {
+            depImports += `import '../${depName}/${depName}.js';\n`;
+         }
+
+      });
+
+      const copySrc = () => {
+         fse.copySync(`${projectPath}/${utils.dirs.src}/`, buildDir);
+      };
+
+      const copyEnv = () => {
+         if (env) {
+            fse.copySync(`${buildDir}/env/${env}.js`, `${buildDir}/env.js`);
+         }
+      };
+
+      const buildJS = () => {
+         walkDirSync(buildDir, buildDirFilter, preprocessJsImport);
+
+         const jsString = project.components.reduce((acc, cur) => {
+            const cmpName = utils.getComponentName(cur);
+            let importString = `import './components/${cur}/${cmpName}.js';`;
+            return acc + importString + '\n';
+         }, depImports + '\n');
+         fs.writeFileSync(`${buildDir}/${project.name}.js`, jsString);
+      };
+
+      const buildHTML = () => {
+         project.components.forEach(cmp => {
+            const cmpName = utils.getComponentName(cmp);
+            const htmlFilename = `${projectPath}/${buildDir}/components/${cmp}/${cmpName}.html`;
+            const htmlFileExists = fs.existsSync(htmlFilename);
+            if (htmlFileExists) {
+
+               const scssFilename = `${projectPath}/${buildDir}/components/${cmp}/${cmpName}.scss`;
+               const scssFileExists = fs.existsSync(scssFilename);
+               let cssString = '';
+               if (scssFileExists) {
+                  let scssString = `@import "global-styles.scss";\n`;
+                  scssString += fs.readFileSync(scssFilename, 'utf8');
+                  scssString += '\n[lw-false],[lw-for]{display:none !important;}\n';
+                  cssString = utils.buildCSS(scssString, `${projectPath}/${buildDir}/components/${cmp}`);
+               }
+               const styleString = cssString || '';
+               const htmlString = fs.readFileSync(htmlFilename, 'utf8');
+               const ast = parser.parse(htmlString);
+               ast.css = styleString;
+               ast.componentFullName = project.name + '-' + cmp.replace(/\//g, '-');
+               ast.runtimeVersion = project.version;
+               ast.builderVersion = leanwebPackageJSON.version;
+               fs.writeFileSync(`${buildDir}/components/${cmp}/ast.js`, `export default ${JSON.stringify(ast, null, 0)};`);
+            }
+         });
+         const htmlString = fs.readFileSync(`${projectPath}/${buildDir}/index.html`, 'utf8');
+         fs.writeFileSync(`${buildDir}/index.html`, htmlString);
+      };
+
+      const buildSCSS = () => {
+         const projectScssFilename = `${projectPath}/src/${project.name}.scss`;
+         let projectCssString = '';
+         if (fs.existsSync(projectScssFilename)) {
+            const projectScssString = fs.readFileSync(projectScssFilename, 'utf8');
+            projectCssString += utils.buildCSS(projectScssString, `${projectPath}/${buildDir}`);
+         }
+         fs.writeFileSync(`${buildDir}/${project.name}.css`, projectCssString);
+      };
+
+      copySrc();
+      copyEnv();
+      buildJS();
+      buildSCSS();
+      buildHTML();
+
+      return project.name;
+   };
+
+   buildModule(process.cwd());
+
+})();

package/commands/clean.js

@@ -0,0 +1,8 @@
+const fs = require('fs');
+const utils = require('./utils.js');
+
+(async () => {
+   fs.rmSync(utils.dirs.build + '/', { recursive: true, force: true });
+   fs.rmSync(utils.dirs.dist + '/', { recursive: true, force: true });
+   fs.rmSync(utils.dirs.serve + '/', { recursive: true, force: true });
+})();

package/commands/destroy.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const utils = require('./utils.js');
+
+const args = process.argv;
+if (args.length < 3) {
+   console.log('Usage: lw destroy project-name');
+   console.log(`This will delete ${utils.dirs.src}/ ${utils.dirs.build}/ ${utils.dirs.dist}/ ${utils.dirs.serve}/ and ${utils.dirs.electron}/`)
+   return;
+}
+
+const projectName = args[2];
+
+const project = require(`${process.cwd()}/${utils.dirs.src}/leanweb.json`);
+
+if (projectName !== project.name) {
+   console.error('Error: project name doesn\'t match.');
+   return;
+}
+
+fs.rmSync(utils.dirs.build + '/', { recursive: true, force: true });
+fs.rmSync(utils.dirs.dist + '/', { recursive: true, force: true });
+fs.rmSync(utils.dirs.src + '/', { recursive: true, force: true });
+fs.rmSync(utils.dirs.serve + '/', { recursive: true, force: true });
+fs.rmSync(utils.dirs.electron + '/', { recursive: true, force: true });

package/commands/dist.js

@@ -0,0 +1,61 @@
+const webpack = require('webpack');
+const utils = require('./utils.js');
+const fs = require('fs');
+const fse = require('fs-extra');
+const minify = require('html-minifier').minify;
+const CleanCSS = require('clean-css');
+
+let env = '';
+const args = process.argv;
+if (args.length >= 3) {
+   env = args[2];
+}
+
+(async () => {
+   const project = require(`${process.cwd()}/${utils.dirs.src}/leanweb.json`);
+
+   await utils.exec(`npx lw clean`);
+   await utils.exec(`npx lw build ${env}`);
+
+   const webpackConfig = utils.getWebPackConfig(utils.dirs.dist, project);
+
+   const compiler = webpack({
+      ...webpackConfig,
+      mode: 'production',
+      devtool: 'source-map',
+      performance: {
+         hints: false,
+      },
+   });
+
+   compiler.run(async (err, stats) => {
+      if (err) {
+         console.log(err);
+      }
+      if (stats.compilation.errors.length) {
+         console.log(stats.compilation.errors);
+      }
+      if (stats.compilation.warnings.length) {
+         console.log(stats.compilation.warnings);
+      }
+
+      const indexHTML = fs.readFileSync(`./${utils.dirs.build}/index.html`, 'utf8');
+      const minifiedIndexHtml = minify(indexHTML, {
+         caseSensitive: true,
+         collapseWhitespace: true,
+         minifyCSS: true,
+         minifyJS: true,
+         caseSensitive: true,
+      });
+      fs.writeFileSync(`./${utils.dirs.dist}/index.html`, minifiedIndexHtml);
+
+      const appCSS = fs.readFileSync(`./${utils.dirs.build}/${project.name}.css`, 'utf8');
+      const minifiedAppCss = new CleanCSS({}).minify(appCSS);
+      fs.writeFileSync(`./${utils.dirs.dist}/${project.name}.css`, minifiedAppCss.styles);
+
+      fse.copySync(`./${utils.dirs.build}/favicon.svg`, `./${utils.dirs.dist}/favicon.svg`);
+      project.resources.forEach(resource => {
+         fse.copySync(`./${utils.dirs.build}/${resource}`, `./${utils.dirs.dist}/${resource}`);
+      });
+   });
+})();

package/commands/electron.js

@@ -0,0 +1,59 @@
+(async () => {
+   const fs = require('fs');
+   const fse = require('fs-extra');
+   const webpack = require('webpack');
+   const utils = require('./utils.js');
+
+   let env = '';
+   const args = process.argv;
+   if (args.length >= 3) {
+      env = args[2];
+   }
+
+   if (!fs.existsSync(process.cwd() + `/${utils.dirs.src}/electron.js`)) {
+      fse.copySync(`${__dirname}/../templates/electron.js`, `${process.cwd()}/${utils.dirs.src}/electron.js`);
+   }
+
+   const leanwebJSONPath = `${process.cwd()}/${utils.dirs.src}/leanweb.json`;
+   const project = require(leanwebJSONPath);
+   if (!project.electron) {
+      utils.exec(`npm i -D electron --loglevel=error`);
+      project.electron = true;
+      fs.writeFileSync(leanwebJSONPath, JSON.stringify(project, null, 2));
+   }
+
+   await utils.exec(`npx lw clean`);
+   await utils.exec(`npx lw build ${env}`);
+
+   fse.copySync(`./${utils.dirs.build}/electron.js`, `./${utils.dirs.electron}/electron.js`);
+   fse.copySync(`./${utils.dirs.build}/index.html`, `./${utils.dirs.electron}/index.html`);
+   fse.copySync(`./${utils.dirs.build}/${project.name}.css`, `./${utils.dirs.electron}/${project.name}.css`);
+   fse.copySync(`./${utils.dirs.build}/favicon.svg`, `./${utils.dirs.electron}/favicon.svg`);
+   project.resources && project.resources.forEach(resource => {
+      fse.copySync(`./${utils.dirs.build}/${resource}`, `./${utils.dirs.electron}/${resource}`);
+   });
+
+   const webpackConfig = utils.getWebPackConfig(utils.dirs.electron, project);
+
+   const compiler = webpack({
+      ...webpackConfig,
+      mode: 'development',
+      devtool: 'eval-cheap-module-source-map',
+      performance: {
+         hints: false,
+      },
+   });
+
+   compiler.run(async (err, stats) => {
+      if (err) {
+         console.log(err);
+      }
+      if (stats.compilation.errors.length) {
+         console.log(stats.compilation.errors);
+      }
+      if (stats.compilation.warnings.length) {
+         console.log(stats.compilation.warnings);
+      }
+      await utils.exec(`npx electron ${process.cwd()}/${utils.dirs.electron}/electron.js`);
+   });
+})();

package/commands/generate.js

@@ -0,0 +1,50 @@
+(async () => {
+   const fs = require('fs');
+   const utils = require('./utils.js');
+
+   const args = process.argv;
+   if (args.length < 3) {
+      console.error('Usage: lw generate component-names');
+      return;
+   }
+
+   const leanwebJSONPath = `${process.cwd()}/${utils.dirs.src}/leanweb.json`;
+   const leanwebJSON = require(leanwebJSONPath);
+   const cmps = args.slice(2);
+
+   for (const cmpJSON of leanwebJSON.components) {
+      for (const cmp of cmps) {
+         if (cmpJSON === cmp) {
+            console.error(`Error: component ${cmpJSON} existed.`);
+            return;
+         }
+      }
+   }
+
+   leanwebJSON.components.push(...cmps);
+   fs.writeFileSync(leanwebJSONPath, JSON.stringify(leanwebJSON, null, 2));
+
+   for (const cmp of cmps) {
+      const cmpName = utils.getComponentName(cmp);
+      const cmpPath = `${utils.dirs.src}/components/${cmp}`;
+
+      fs.mkdirSync(cmpPath, { recursive: true });
+
+      if (!fs.existsSync(`${cmpPath}/${cmpName}.js`)) {
+         let jsString = fs.readFileSync(`${__dirname}/../templates/component.js`, 'utf8');
+         jsString = jsString.replace(/\$\{projectName\}/g, leanwebJSON.name);
+         jsString = jsString.replace(/\$\{component\}/g, cmp.replace(/\//g, '-'));
+         jsString = jsString.replace(/\$\{pathLevels\}/g, utils.getPathLevels(cmp));
+
+         fs.writeFileSync(`${cmpPath}/${cmpName}.js`, jsString);
+      }
+
+      if (!fs.existsSync(`${cmpPath}/${cmpName}.html`)) {
+         fs.writeFileSync(`${cmpPath}/${cmpName}.html`, `<div>${leanwebJSON.name}-${cmpName} works!</div>`);
+      }
+
+      if (!fs.existsSync(`${cmpPath}/${cmpName}.scss`)) {
+         fs.writeFileSync(`${cmpPath}/${cmpName}.scss`, '');
+      }
+   }
+})();

package/commands/help.js

@@ -0,0 +1,32 @@
+(async () => {
+
+   const utils = require('./utils.js');
+
+   if (process.argv.length < 3) {
+      utils.exec('npx lw version');
+      console.log('Usage: lw target parameters');
+      console.log('Targets:\n');
+      Object.keys(utils.targets).forEach(t => {
+         console.log(t);
+      });
+      console.log();
+      return;
+   }
+
+   let target = process.argv[2];
+
+   const targetCandidates = Object.keys(utils.targets).filter(t => t.startsWith(target));
+
+   if (targetCandidates.length === 0) {
+      console.error(`Error: target ${target} not found.`);
+      return;
+   } else if (targetCandidates.length > 1) {
+      targetCandidates.forEach(t => {
+         console.log(t);
+      });
+      return;
+   }
+
+   target = targetCandidates[0];
+   console.log(utils.targets[target].note);
+})();

package/commands/init.js

@@ -0,0 +1,101 @@
+(async () => {
+   const fs = require('fs');
+   const fse = require('fs-extra');
+   const path = require('path');
+   const git = require('isomorphic-git');
+   const globby = require('globby');
+   const args = process.argv;
+   const utils = require('./utils.js');
+
+   const leanwebJSONExisted = fs.existsSync(`${process.cwd()}/${utils.dirs.src}/leanweb.json`);
+   const packageJSONExisted = fs.existsSync(`${process.cwd()}/package.json`);
+
+   const lwPackage = require(`${__dirname}/../package.json`);
+
+   if (leanwebJSONExisted) {
+      console.error('Error: leanweb.json existed.');
+      return;
+   }
+
+   if (!packageJSONExisted) {
+      utils.exec(`npm init -y`);
+   }
+
+   let projectName = path.basename(path.resolve());
+
+   if (args.length >= 3) {
+      projectName = args[2];
+   }
+
+   const leanwebData = {
+      name: projectName,
+      version: lwPackage.version,
+      components: [],
+      imports: [],
+      resources: [
+         'resources/'
+      ],
+   };
+
+   const projectScss = `// html,
+// body {
+   // height: 100%;
+   // width: 100%;
+   // margin: 0 auto;
+   // padding: 0;
+
+   // font-family: "Roboto", "Helvetica", "Arial", sans-serif;
+// }
+`
+
+   const globalScss = `// div {
+//    color: tomato;
+// }
+`;
+
+   fs.mkdirSync(`${utils.dirs.src}/resources/`, { recursive: true });
+   fs.writeFileSync(`${utils.dirs.src}/leanweb.json`, JSON.stringify(leanwebData, null, 2));
+
+   utils.exec(`npm i -D @babel/runtime --loglevel=error`);
+
+   utils.exec(`npx lw generate root`);
+
+   fse.copySync(`${__dirname}/../templates/lib`, `./${utils.dirs.src}/lib/`);
+
+   let htmlString = fs.readFileSync(`${__dirname}/../templates/index.html`, 'utf8');
+   htmlString = htmlString.replace(/\$\{project\.name\}/g, projectName);
+   fs.writeFileSync(`./${utils.dirs.src}/index.html`, htmlString);
+   fs.writeFileSync(`./src/${projectName}.scss`, projectScss);
+   fs.writeFileSync(`./${utils.dirs.src}/global-styles.scss`, globalScss);
+   fse.copySync(`${__dirname}/../templates/favicon.svg`, `./${utils.dirs.src}/favicon.svg`);
+   fse.copySync(`${__dirname}/../templates/env.js`, `./${utils.dirs.src}/env.js`);
+   fse.copySync(`${__dirname}/../templates/env/`, `./${utils.dirs.src}/env/`);
+
+   if (!(fs.existsSync(`${process.cwd()}/.git/`) && fs.statSync(`${process.cwd()}/.git/`).isDirectory())) {
+      await git.init({ fs, dir: process.cwd() });
+
+      if (fs.existsSync(`${process.cwd()}/.gitignore`) && fs.statSync(`${process.cwd()}/.gitignore`).isFile()) {
+         fs.appendFileSync(`${process.cwd()}/.gitignore`, `\nnode_modules/\n${utils.dirs.build}/\n${utils.dirs.dist}/\n${utils.dirs.serve}/\n${utils.dirs.electron}/\n`, 'utf8');
+      } else {
+         fs.writeFileSync(`${process.cwd()}/.gitignore`, `node_modules/\n${utils.dirs.build}/\n${utils.dirs.dist}/\n${utils.dirs.serve}/\n${utils.dirs.electron}/\n`, 'utf8');
+      }
+
+      const paths = await globby(['./**', './**/.*'], { gitignore: true });
+      for (const filepath of paths) {
+         await git.add({ fs, dir: process.cwd(), filepath });
+      }
+      await git.commit({
+         fs,
+         dir: process.cwd(),
+         author: {
+            name: 'Leanweb',
+            email: 'leanweb@leanweb.app',
+         },
+         message: 'lw init'
+      });
+      console.log('\nSome useful commands:');
+      console.log('"lw s" to start the dev server.');
+      console.log('"lw d" to build for production. The output will be in dist/ directory.');
+      console.log('"lw g my-new-component" to generate a new standard web component.');
+   }
+})();

package/commands/serve.js

@@ -0,0 +1,71 @@
+const fse = require('fs-extra');
+const utils = require('./utils.js');
+const webpack = require('webpack');
+const watch = require('node-watch');
+const WebpackDevServer = require('webpack-dev-server');
+
+let env = '';
+const args = process.argv;
+if (args.length >= 3) {
+   env = args[2];
+}
+
+const address = process.env.address || '127.0.0.1';
+let port = process.env.port || 2020;
+const noopen = process.env.noopen || false;
+
+(async () => {
+
+   const project = require(`${process.cwd()}/${utils.dirs.src}/leanweb.json`);
+
+   const build = async (eventType, filename) => {
+      // console.log(eventType + ': ', filename);
+      try {
+         await utils.exec(`npx lw build ${env}`);
+         fse.copySync(`./${utils.dirs.build}/index.html`, `./${utils.dirs.serve}/index.html`);
+         fse.copySync(`./${utils.dirs.build}/${project.name}.css`, `./${utils.dirs.serve}/${project.name}.css`);
+         fse.copySync(`./${utils.dirs.build}/favicon.svg`, `./${utils.dirs.serve}/favicon.svg`);
+         project.resources?.forEach(resource => {
+            fse.copySync(`./${utils.dirs.build}/${resource}`, `./${utils.dirs.serve}/${resource}`);
+         });
+      } catch (e) {
+         console.error(e);
+      }
+   };
+
+   const throttledBuild = utils.throttle(build);
+   watch(process.cwd() + `/${utils.dirs.src}/`, { recursive: true }, (eventType, filename) => {
+      throttledBuild(eventType, filename);
+   });
+
+   build();
+
+   const webpackConfig = utils.getWebPackConfig(utils.dirs.serve, project);
+
+   const webpackDevConfig = {
+      ...webpackConfig,
+      mode: 'development',
+      // watch: true,
+      devtool: 'eval-cheap-module-source-map',
+      performance: {
+         hints: false,
+      },
+   };
+
+   const compiler = webpack(webpackDevConfig);
+
+   const devServerOptions = {
+      ...webpackDevConfig.devServer,
+      static: {
+         directory: process.cwd() + `/${utils.dirs.serve}/`,
+         watch: true,
+      },
+      open: !noopen,
+   };
+   const server = new WebpackDevServer(devServerOptions, compiler);
+
+   while (await utils.portInUse(port, address)) {
+      ++port;
+   }
+   server.start(port, address);
+})();

package/commands/upgrade.js

@@ -0,0 +1,53 @@
+const semver = require('semver');
+const fs = require('fs');
+const fse = require('fs-extra');
+const utils = require('./utils.js');
+
+const leanwebPackageJSON = require(`${__dirname}/../package.json`);
+const projectLeanwebJSON = require(`${process.cwd()}/${utils.dirs.src}/leanweb.json`);
+
+const upgradeTo045 = () => {
+   const projectName = projectLeanwebJSON.name;
+   projectLeanwebJSON.components.forEach(cmp => {
+      const component = projectName + '-' + cmp;
+
+      const filePath = process.cwd() + `/${utils.dirs.src}/components/` + cmp + '/' + cmp + '.js';
+      const oldSrc = fs.readFileSync(filePath, 'utf8');
+      const newSrc = oldSrc.replace(/import\s+interpolation\s+from\s+\'.\/ast\.js\';/, 'import ast from \'./ast.js\';')
+         .replace(/const\s+component\s+=\s+{\s+id\:\s+'.+?',\s+interpolation\s+};/, '')
+         .replace(/component\.id/g, '\'' + component + '\'')
+         .replace(/super\(component\);/, 'super(ast);');
+      fs.writeFileSync(filePath, newSrc);
+   });
+};
+
+const upgradeTo081 = () => {
+   fse.copySync(`${__dirname}/../templates/env`, `./${utils.dirs.src}/env/`);
+   fse.copySync(`${__dirname}/../templates/env.js`, `./${utils.dirs.src}/env.js`);
+};
+
+const upgradeTo088 = () => {
+   utils.exec(`npm i -D @babel/runtime --loglevel=error`);
+};
+
+const upgradeAvailable = semver.gt(leanwebPackageJSON.version, projectLeanwebJSON.version);
+if (upgradeAvailable) {
+   fse.copySync(`${__dirname}/../templates/lib`, `./${utils.dirs.src}/lib/`);
+   const oldVersion = projectLeanwebJSON.version;
+   projectLeanwebJSON.version = leanwebPackageJSON.version;
+   fs.writeFileSync(`${process.cwd()}/${utils.dirs.src}/leanweb.json`, JSON.stringify(projectLeanwebJSON, null, 2));
+
+   if (semver.gte(leanwebPackageJSON.version, '0.4.5') && semver.lt(oldVersion, '0.4.5')) {
+      upgradeTo045();
+   }
+
+   if (semver.gte(leanwebPackageJSON.version, '0.8.1') && semver.lt(oldVersion, '0.8.1')) {
+      upgradeTo081();
+   }
+
+   if (semver.gte(leanwebPackageJSON.version, '0.8.8') && semver.lt(oldVersion, '0.8.8')) {
+      upgradeTo088();
+   }
+
+   console.log('Leanweb upgraded:', oldVersion, '=>', leanwebPackageJSON.version);
+}