@bigcommerce/stencil-cli 8.3.0 → 8.4.0

package/lib/release/release.js

@@ -1,16 +1,16 @@
-const os = require('os');
-const uuid = require('uuid4');
-const fsModule = require('fs');
-const path = require('path');
-const octokitModule = require('@octokit/rest');
-const simpleGit = require('simple-git');
-
-const ThemeConfig = require('../theme-config');
-const askQuestions = require('./questions');
-const Bundle = require('../stencil-bundle');
-const StencilConfigManager = require('../StencilConfigManager');
-const fsUtilsModule = require('../utils/fsUtils');
-const { THEME_PATH } = require('../../constants');
+import os from 'os';
+import uuid from 'uuid4';
+import fsModule from 'fs';
+import path from 'path';
+// eslint-disable-next-line import/no-unresolved, node/no-missing-import
+import { Octokit as octokitModule } from '@octokit/rest';
+import simpleGit from 'simple-git';
+import ThemeConfig from '../theme-config.js';
+import askQuestions from './questions.js';
+import Bundle from '../stencil-bundle.js';
+import StencilConfigManager from '../StencilConfigManager.js';
+import fsUtilsModule from '../utils/fsUtils.js';
+import { THEME_PATH } from '../../constants.js';
 
 class StencilRelease {
     constructor({
@@ -34,34 +34,25 @@ class StencilRelease {
     async run(cliOptions) {
         const gitData = await this.getGitData();
         this.checkGitData(gitData, cliOptions);
-
         const version = await this._themeConfigManager.getVersion();
         this.checkCurrentVersion(version);
-
         const answers = await askQuestions(version, await this.getGithubToken(), gitData.remotes);
-
         await this.saveGithubToken(answers.githubToken);
-
         const options = {
             ...answers,
             ...cliOptions,
         };
         await this.doRelease(options);
-
         this._logger.log('done'.green);
-
         return true;
     }
 
     async getGitData() {
         const status = await this._git.status();
-
         const response = await this._git.getRemotes(true);
-
         const remotes = response.map((remote) => {
             const url = remote.refs.push || '';
-            const match = url.match(/github\.com[/|:](.+?)\/(.+?)[/|.]/);
-
+            const match = url.match(/github\.com[/|:](.+)\/(.+)/);
             return {
                 name: remote.name,
                 url,
@@ -69,7 +60,6 @@ class StencilRelease {
                 repo: match ? match[2] : null,
             };
         });
-
         const dirty =
             status.not_added.length > 0 ||
             status.conflicted.length > 0 ||
@@ -77,7 +67,6 @@ class StencilRelease {
             status.deleted.length > 0 ||
             status.modified.length > 0 ||
             status.renamed.length > 0;
-
         return { dirty, ...status, remotes };
     }
 
@@ -94,21 +83,17 @@ class StencilRelease {
         if (gitData.remotes.length === 0) {
             throw new Error('No git remote repository found');
         }
-
         if (gitData.current !== options.branch) {
             throw new Error(
                 `Not on ${options.branch} branch, please checkout ${options.branch} branch to proceed`,
             );
         }
-
         if (gitData.dirty) {
             throw new Error('git tree is dirty, please commit changes to proceed');
         }
-
         if (gitData.behind !== 0) {
             throw new Error(`Your branch is behind by ${gitData.behind} commits`);
         }
-
         if (gitData.ahead !== 0) {
             this.printWarning(`your branch is ahead by ${gitData.ahead} commits`);
         }
@@ -126,31 +111,24 @@ class StencilRelease {
 
     async getGithubToken() {
         const data = (await this._stencilConfigManager.read(true)) || {};
-
         return data.githubToken;
     }
 
     async saveGithubToken(githubToken) {
         const data = (await this._stencilConfigManager.read(true)) || {};
-
         data.githubToken = githubToken;
-
         await this._stencilConfigManager.save(data);
     }
 
     async doRelease(options) {
         // Update changelog and get text for release notes
         const changelog = await this.parseChangelog(options.version, options.date);
-
         await this.bumpJsonFileVersion(this._themeConfigManager.configPath, options.version);
         await this.bumpJsonFileVersion(path.join(THEME_PATH, 'package.json'), options.version);
         await this.bumpJsonFileVersion(path.join(THEME_PATH, 'package-lock.json'), options.version);
-
         const bundlePath = await this.bundleTheme();
-
         try {
             await this.commitAndPush(options.version, options.remote, options.branch);
-
             if (options.createGithubRelease) {
                 await this.createGithubRelease(
                     options.version,
@@ -167,27 +145,22 @@ class StencilRelease {
     async parseChangelog(version, date) {
         const filePath = path.join(THEME_PATH, 'CHANGELOG.md');
         let changelog = '';
-
         try {
             changelog = await this._fs.promises.readFile(filePath, 'utf8');
         } catch (e) {
             // no CHANGELOG file
             return null;
         }
-
         const match = changelog.match(/##\s*?draft\s*?\n([\s\S]*?)(##|$)/i);
-
         // bump the version and date
         changelog = changelog.replace(
             /##\s*?draft\s*?\n/i,
             `## Draft\n\n## ${version} (${date})\n`,
         );
-
         // Update the changelog file if this is a full release
         if (!this.isReleaseCandidate(version)) {
             await this._fs.promises.writeFile(filePath, changelog);
         }
-
         return match ? match[1].trim() : null;
     }
 
@@ -197,7 +170,6 @@ class StencilRelease {
 
     async bumpJsonFileVersion(filePath, version) {
         const data = await this._fsUtils.parseJsonFile(filePath);
-
         data.version = version;
         await this._fs.promises.writeFile(filePath, `${JSON.stringify(data, null, 2)}\n`);
     }
@@ -209,24 +181,19 @@ class StencilRelease {
             name: uuid(),
         };
         const bundle = new Bundle(THEME_PATH, this._themeConfigManager, rawConfig, bundleOptions);
-
         return bundle.initBundle();
     }
 
     async commitAndPush(version, remote, branch) {
         await this._git.add(['config.json', 'package.json', 'package-lock.json', 'CHANGELOG.md']);
         const summary = await this._git.commit(`Releasing ${version}`);
-
         this._logger.log(`Pushing Changes to ${remote.name}...`);
-
         await this._git.push(remote.name, branch);
-
         return summary.commit;
     }
 
     async createGithubRelease(version, changelog, remote, bundlePath) {
         const github = await this.getGithubClient();
-
         const releaseParams = {
             owner: remote.owner,
             repo: remote.repo,
@@ -234,14 +201,10 @@ class StencilRelease {
             body: changelog || '',
             prerelease: this.isReleaseCandidate(version),
         };
-
         this._logger.log('Creating Github Release...');
-
         const release = await github.repos.createRelease(releaseParams);
         const themeName = await this._themeConfigManager.getName();
-
         this._logger.log('Uploading Bundle File...');
-
         const zipFile = await this._fs.promises.readFile(bundlePath);
         const uploadParams = {
             release_id: release.data.id,
@@ -251,16 +214,14 @@ class StencilRelease {
             name: `${themeName}-${version}.zip`,
         };
         const asset = await github.repos.uploadReleaseAsset(uploadParams);
-
         this._logger.log(`Release url: ${release.data.html_url.green}`);
         this._logger.log(`Bundle download url: ${asset.data.browser_download_url.green}`);
     }
 
     async getGithubClient() {
-        return new this._octokit.Octokit({
+        return new this._octokit({
             auth: await this.getGithubToken(),
         });
     }
 }
-
-module.exports = StencilRelease;
+export default StencilRelease;

package/lib/spinner.js

@@ -6,5 +6,4 @@ const spinner = async (action, options) => {
         ...options,
     });
 };
-
-module.exports = spinner;
+export default spinner;

package/lib/stencil-bundle.js

@@ -1,18 +1,17 @@
-const upath = require('upath');
-const Archiver = require('archiver');
-const async = require('async');
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const StencilStyles = require('@bigcommerce/stencil-styles');
-
-const BuildConfigManager = require('./BuildConfigManager');
-const BundleValidator = require('./bundle-validator');
-const Cycles = require('./Cycles');
-const langAssembler = require('./lang-assembler');
-const templateAssembler = require('./template-assembler');
-const { recursiveReadDir } = require('./utils/fsUtils');
-const { fetchRegions } = require('./regions');
+import upath from 'upath';
+import Archiver from 'archiver';
+import async from 'async';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import StencilStyles from '@bigcommerce/stencil-styles';
+import BuildConfigManager from './BuildConfigManager.js';
+import BundleValidator from './bundle-validator.js';
+import Cycles from './Cycles.js';
+import langAssembler from './lang-assembler.js';
+import templateAssembler from './template-assembler.js';
+import { recursiveReadDir } from './utils/fsUtils.js';
+import { fetchRegions } from './regions.js';
 
 const MEGABYTE = 1024 * 1024;
 const MAX_SIZE_BUNDLE = MEGABYTE * 50;
@@ -49,27 +48,22 @@ class Bundle {
     ) {
         const tasks = {};
         this.options = options;
-
         this.templatesPath = path.join(themePath, 'templates');
         this.themePath = themePath;
         this.themeConfig = themeConfig;
         this.configuration = rawConfig;
-
         this.validator = new BundleValidator(
             this.themePath,
             this.themeConfig,
             this.options.marketplace !== true,
         );
-
         if (this.configuration.css_compiler) {
             tasks.css = this.getCssAssembleTask(this.configuration.css_compiler);
         }
-
         tasks.templates = this.assembleTemplatesTask.bind(this);
         tasks.lang = this.assembleLangTask.bind(this);
         tasks.schema = this.assembleSchema.bind(this);
         tasks.schemaTranslations = this.assembleSchemaTranslations.bind(this);
-
         if (typeof buildConfigManager.production === 'function') {
             tasks.theme = (callback) => {
                 console.log('Theme task Started...');
@@ -77,16 +71,12 @@ class Bundle {
                     if (err) {
                         return callback(err);
                     }
-
                     console.log(`${'ok'.green} -- Theme task Finished`);
-
                     return callback();
                 });
             };
         }
-
         this.tasks = tasks;
-
         this._getExternalLibs = this._getExternalLibs.bind(this);
     }
 
@@ -120,7 +110,6 @@ class Bundle {
             } else {
                 basePath = path.join(this.themePath, 'assets', compiler);
             }
-
             console.log('%s Parsing Started...', compiler.toUpperCase());
             fs.readdir(basePath, (err, files) => {
                 const filterFiles = files.filter((file) => {
@@ -141,11 +130,9 @@ class Bundle {
                         if (assemblingError) {
                             return callback(assemblingError);
                         }
-
                         filterFiles.forEach((file, index) => {
                             ret[file] = results[index];
                         });
-
                         console.log(`${'ok'.green} -- %s Parsing Finished`, compiler.toUpperCase());
                         return callback(null, ret);
                     },
@@ -166,14 +153,10 @@ class Bundle {
         const content = await fs.promises.readFile(templatePath, { encoding: 'utf-8' });
         const externalPathRegex = /{{2}>\s*(['"]external)[^{]*?}{2}/g;
         const externalTemplatesImports = content.match(externalPathRegex);
-
         if (!externalTemplatesImports) return [];
-
         return externalTemplatesImports.map((templateImport) => {
             const [, importPath] = templateAssembler.partialRegex.exec(templateImport);
-
             templateAssembler.partialRegex.lastIndex = 0;
-
             return importPath
                 .split('/templates/')[0]
                 .slice(templateAssembler.packageMarker.length + 1);
@@ -184,17 +167,14 @@ class Bundle {
         console.log('Template Parsing Started...');
         const internalTemplatesList = await recursiveReadDir(this.templatesPath, ['!*.html']);
         let externalLibs;
-
         try {
             const removeDuplicates = (arr) => Array.from(new Set(arr.flat()));
             const temp = internalTemplatesList.map(this._getExternalLibs);
             const result = await Promise.all(temp);
-
             externalLibs = removeDuplicates(result);
         } catch (error) {
             callback(error);
         }
-
         let externalLibPaths = [];
         if (externalLibs.length) {
             externalLibPaths = externalLibs.map((lib) =>
@@ -222,33 +202,26 @@ class Bundle {
                     );
                 });
                 partials.push(...extractedPartials);
-
                 return partials;
             },
             [],
         );
         const allPartials = [...externalPartials, ...internalPartials];
-
         let results;
         try {
             results = await async.map(
                 allPartials,
                 templateAssembler.assembleAndBundle.bind(null, this.templatesPath),
             );
-
             const ret = {};
-
             allPartials.forEach((file, index) => {
                 ret[file] = results[index];
             });
-
             await Promise.all([
                 this._checkObjects.bind(this, results),
                 this._detectCycles.bind(this, results),
             ]);
-
             console.log(`${'ok'.green} -- Template Parsing Finished`);
-
             return ret;
         } catch (err) {
             return callback(err);
@@ -257,21 +230,15 @@ class Bundle {
 
     async assembleSchema() {
         console.log('Building Theme Schema File...');
-
         const schema = await this.themeConfig.getSchema();
-
         console.log(`${'ok'.green} -- Theme Schema Building Finished`);
-
         return schema;
     }
 
     async assembleSchemaTranslations() {
         console.log('Schema Translations Parsing Started...');
-
         const schema = await this.themeConfig.getSchemaTranslations();
-
         console.log(`${'ok'.green} -- Schema Translations Parsing Finished`);
-
         return schema;
     }
 
@@ -281,7 +248,6 @@ class Bundle {
             if (err) {
                 return callback(err);
             }
-
             console.log(`${'ok'.green} -- Language Files Parsing Finished`);
             return callback(null, results);
         });
@@ -289,20 +255,16 @@ class Bundle {
 
     generateManifest(taskResults, callback) {
         console.log('Generating Manifest Started...');
-
         recursiveReadDir(this.templatesPath, ['!*.html'], (err, filePaths) => {
             if (err) {
                 return callback(err);
             }
-
             const templates = filePaths.map((file) => {
                 return upath.toUnix(
                     file.replace(this.templatesPath + path.sep, '').replace('.html', ''),
                 );
             });
-
             const regions = fetchRegions(taskResults.templates, templates);
-
             console.log(`${'ok'.green} -- Manifest Generation Finished`);
             return callback(null, {
                 regions,
@@ -323,7 +285,6 @@ class Bundle {
                 console.error('error '.red + err.message);
                 return callback(err);
             }
-
             return callback();
         });
     }
@@ -350,7 +311,6 @@ class Bundle {
      */
     _validateTheme(callback) {
         console.log('Validating theme...');
-
         this.validator.validateTheme((err) => {
             if (err) {
                 throw err;
@@ -373,34 +333,27 @@ class Bundle {
         const outputFolder =
             typeof this.options.dest === 'string' ? this.options.dest : this.themePath;
         const bundleZipPath = path.join(outputFolder, outputName);
-
         this.tasks.templates = this.assembleTemplatesTask.bind(this, callback);
-
         async
             .parallel(this.tasks)
             .then((taskResults) => {
                 const archive = Archiver('zip');
                 const fileStream = fs.createWriteStream(bundleZipPath);
                 archive.pipe(fileStream);
-
                 // Create manifest will use taskResults to generate a manifest file
                 return this.generateManifest(taskResults, (manifestGenerationError, manifest) => {
                     if (manifestGenerationError) {
                         return callback(manifestGenerationError);
                     }
-
                     // eslint-disable-next-line no-param-reassign
                     taskResults.manifest = manifest;
                     // zip theme files
                     this._bundleThemeFiles(archive, this.themePath);
-
                     // zip all generated files
                     const failedTemplates = this._bundleParsedFiles(archive, taskResults);
-
                     fileStream.on('close', () => {
                         const stats = fs.statSync(bundleZipPath);
                         const { size } = stats;
-
                         if (failedTemplates.length) {
                             return console.error(
                                 `Error: Your bundle failed as templates generated from the files below are greater than or equal to 1 megabyte in size:\n${failedTemplates.join(
@@ -408,18 +361,14 @@ class Bundle {
                                 )}`,
                             );
                         }
-
                         if (size > MAX_SIZE_BUNDLE) {
                             return console.error(
                                 `Error: Your bundle of size ${size} bytes is above the max size of ${MAX_SIZE_BUNDLE} bytes`,
                             );
                         }
-
                         console.log(`${'ok'.green} -- Zipping Files Finished`);
-
                         return callback(null, bundleZipPath);
                     });
-
                     // This triggers 'close' event in the file stream. No need to callback()
                     return archive.finalize();
                 });
@@ -454,7 +403,6 @@ class Bundle {
             archive.append(JSON.stringify(data, null, 2), { name });
         };
         const failedTemplates = [];
-
         for (const [task, result] of Object.entries(taskResults)) {
             switch (task) {
                 case 'css':
@@ -464,11 +412,9 @@ class Bundle {
                             this.configuration.css_compiler === 'css'
                                 ? this.configuration.css_compiler
                                 : 'scss';
-
                         archiveJsonFile(data, `parsed/${ext}/${filename}.json`);
                     }
                     break;
-
                 case 'templates':
                     // Create the parsed tree files
                     for (const [filename, data] of Object.entries(result)) {
@@ -481,27 +427,22 @@ class Bundle {
                         }
                     }
                     break;
-
                 case 'lang':
                     // append the parsed translation file with all translations
                     archiveJsonFile(result, 'parsed/lang.json');
                     break;
-
                 case 'schema':
                     // append the generated schema.json file
                     archiveJsonFile(result, 'schema.json');
                     break;
-
                 case 'schemaTranslations':
                     // append the parsed schemaTranslations.json file
                     archiveJsonFile(result, 'schemaTranslations.json');
                     break;
-
                 case 'manifest':
                     // append the generated manifest.json file
                     archiveJsonFile(result, 'manifest.json');
                     break;
-
                 default:
                     break;
             }
@@ -509,5 +450,4 @@ class Bundle {
         return failedTemplates;
     }
 }
-
-module.exports = Bundle;
+export default Bundle;

package/lib/stencil-download.js

@@ -1,7 +1,7 @@
-const async = require('async');
-const stencilPushUtils = require('./stencil-push.utils');
-const stencilPullUtils = require('./stencil-pull.utils');
-const stencilDownloadUtil = require('./stencil-download.utils');
+import async from 'async';
+import stencilPushUtils from './stencil-push.utils.js';
+import stencilPullUtils from './stencil-pull.utils.js';
+import stencilDownloadUtil from './stencil-download.utils.js';
 
 function stencilDownload(options) {
     return async.waterfall([
@@ -16,5 +16,4 @@ function stencilDownload(options) {
         stencilDownloadUtil.downloadThemeFiles,
     ]);
 }
-
-module.exports = stencilDownload;
+export default stencilDownload;

package/lib/stencil-download.utils.js

@@ -1,15 +1,12 @@
-const tmp = require('tmp-promise');
-const { extractZipFiles } = require('./archiveManager');
-const NetworkUtils = require('./utils/NetworkUtils');
-const themeApiClient = require('./theme-api-client');
+import * as tmp from 'tmp-promise';
+import { extractZipFiles } from './archiveManager.js';
+import NetworkUtils from './utils/NetworkUtils.js';
+import themeApiClient from './theme-api-client.js';
 
 const networkUtils = new NetworkUtils();
-
 const utils = {};
-
 utils.downloadThemeFiles = async (options) => {
     const { path: tempThemePath, cleanup } = await tmp.file();
-
     try {
         await networkUtils.fetchFile(options.downloadUrl, tempThemePath);
     } catch (err) {
@@ -17,43 +14,33 @@ utils.downloadThemeFiles = async (options) => {
             `Unable to download theme files from ${options.downloadUrl}: ${err.message}`,
         );
     }
-
     console.log(`${'ok'.green} -- Theme files downloaded`);
     console.log(`${'ok'.green} -- Extracting theme files`);
-
     await extractZipFiles({
         zipPath: tempThemePath,
         fileToExtract: options.file,
         exclude: options.exclude,
     });
-
     console.log(`${'ok'.green} -- Theme files extracted`);
-
     await cleanup();
-
     return options;
 };
-
 utils.startThemeDownloadJob = async (options) => {
     const {
         config: { accessToken },
         activeTheme,
         storeHash,
     } = options;
-
     const apiHost = options.apiHost || options.config.apiHost;
-
     const { jobId } = await themeApiClient.downloadTheme({
         accessToken,
         themeId: activeTheme.active_theme_uuid,
         apiHost,
         storeHash,
     });
-
     return {
         ...options,
         jobId,
     };
 };
-
-module.exports = utils;
+export default utils;