powerbi-visuals-tools 5.4.2 → 5.5.0

package/Changelog.md

@@ -2,6 +2,15 @@
 
 This page contains information about changes to the PowerBI Visual Tools (pbiviz).
 
+## 5.5.0
+* Changed path for storing certificates. It allows the certificate to be reused regardless of tools version. New path is `({home directory}/pbiviz-certs)`.
+* Windows version lower 10 is deprecated.
+* Resolve of symlinks is disabled.
+
+## 5.4.3
+* Fixed bug with missing plugins for Eslint.
+* New flag `--use-default` for `pbiviz package` and `pbiviz lint` commands. Use this command to lint files according to recommended lint config.
+
 ## 5.4.2
 * Added the **node: false** option to the webpack plugin to eliminate the use of the potentially dangerous **new Function()** method, which ensures compatibility with the Node.js runtime.
 * Introduced support for *.mjs ECMAScript modules.

package/bin/pbiviz.js

@@ -72,6 +72,7 @@ pbiviz
 pbiviz
     .command('lint')
     .option('--fix', 'Enable autofixing of lint errors')
+    .option('--use-default', 'Use recommended eslintrc file')
     .action(options => {
         CommandManager.lint({ ...options, verbose: true }, rootPath);
     });
@@ -100,6 +101,7 @@ pbiviz
     .option('-l, --all-locales', "Keeps all locale files in the package. By default only used inside stringResources folder locales are included.")
     .option('-v, --verbose', "Enables verbose logging")
     .option('--fix', 'Enable autofixing of lint errors')
+    .option('--use-default', 'Use recommended eslintrc file')
     .option('-p, --pbiviz-file <pbiviz-file>', "Path to pbiviz.json file (useful for debugging)", pbivizFile)
     .addOption(new Option('-c, --compression <compressionLevel>', "Enables compression of visual package")
         .choices(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])

package/config.json

@@ -17,9 +17,11 @@
   "package": { "dropFolder": "dist" },
   "server": {
     "assetsRoute": "/assets",
-    "privateKey": "certs/PowerBICustomVisualTest_private.key",
-    "certificate": "certs/PowerBICustomVisualTest_public.crt",
-    "pfx": "certs/PowerBICustomVisualTest_public.pfx"
+    "certificateFolder": "pbiviz-certs",
+    "privateKey": "PowerBICustomVisualTest_private.key",
+    "certificate": "PowerBICustomVisualTest_public.crt",
+    "pfx": "PowerBICustomVisualTest_public.pfx",
+    "passphrase": "PowerBICustomVisualTestPass.txt"
   },
   "visualTemplates": {
     "circlecard": "https://codeload.github.com/microsoft/powerbi-visuals-circlecard-react/zip/master"

package/lib/CertificateTools.js

@@ -30,285 +30,181 @@ import fs from 'fs-extra';
 import os from 'os';
 import path from 'path';
 import crypto from "crypto";
-import { getRootPath, readJsonFromRoot } from './utils.js';
+import { readJsonFromRoot } from './utils.js';
 import ConsoleWriter from './ConsoleWriter.js';
 const certSafePeriod = 1000 * 60 * 60 * 24; // 24 hours
-const rootPath = getRootPath();
-const confPath = '/config.json';
-function exec(command, callback) {
+const config = readJsonFromRoot('config.json');
+const pathToCertFolder = path.join(os.homedir(), config.server.certificateFolder);
+const secretFilesPath = {
+    certPath: path.join(pathToCertFolder, config.server.certificate),
+    keyPath: path.join(pathToCertFolder, config.server.privateKey),
+    pfxPath: path.join(pathToCertFolder, config.server.pfx),
+    passphrasePath: path.join(pathToCertFolder, config.server.passphrase)
+};
+function exec(command, options, callback) {
     return new Promise((resolve, reject) => {
-        nodeExec(command, callback ? callback : (err, stdout, stderr) => {
+        const defaultCallback = (err, stdout, stderr) => {
             if (err) {
                 reject(stderr);
             }
             resolve(stdout);
-        });
+        };
+        nodeExec(command, options, callback ? callback : defaultCallback);
     });
 }
 export async function createCertificate() {
-    const config = readJsonFromRoot('config.json');
-    const certPath = await getCertFile(config, true);
+    const certPath = await getCertFile(true);
     if (!certPath) {
         ConsoleWriter.error("Certificate not found. The new certificate will be generated");
-        await createCertFile(config, true);
+        await createCertFile(true);
     }
     else {
-        await openCertFile(config);
+        await openCertFile();
     }
 }
-export async function createCertFile(config, open) {
+export async function createCertFile(open = false) {
     ConsoleWriter.info(`Generating a new certificate...`);
     const subject = "localhost";
     const keyLength = 2048;
-    const algorithm = "sha256";
     const validPeriod = 365;
-    if (typeof open === 'undefined') {
-        open = false;
-    }
-    const certPath = path.join(rootPath, config.server.certificate);
-    const keyPath = path.join(rootPath, config.server.privateKey);
-    const pfxPath = path.join(rootPath, config.server.pfx);
+    const { certPath, keyPath, pfxPath } = secretFilesPath;
     const openCmds = {
         linux: 'openssl',
         darwin: 'openssl',
-        win32: 'powershell'
+        win32: 'pwsh'
     };
     let startCmd = openCmds[os.platform()];
-    if (startCmd) {
-        try {
-            let createCertCommand = "";
-            switch (os.platform()) {
-                case "linux":
-                    await removeCertFiles(certPath, keyPath);
-                    createCertCommand =
-                        `  req -newkey rsa:${keyLength}` +
-                            ` -nodes` +
-                            ` -keyout ${keyPath}` +
-                            ` -x509 ` +
-                            ` -days ${validPeriod} ` +
-                            ` -out ${certPath} ` +
-                            ` -subj "/CN=${subject}"`;
-                    await exec(`${startCmd} ${createCertCommand}`);
-                    if (await fs.exists(certPath)) {
-                        ConsoleWriter.info(`Certificate generated. Location is ${certPath}`);
-                        if (open) {
-                            await openCertFile(config);
-                        }
-                    }
-                    break;
-                case "darwin":
-                    await removeCertFiles(certPath, keyPath);
-                    createCertCommand =
-                        `  req -newkey rsa:${keyLength}` +
-                            ` -nodes` +
-                            ` -keyout ${keyPath}` +
-                            ` -x509 ` +
-                            ` -days ${validPeriod} ` +
-                            ` -out ${certPath} ` +
-                            ` -subj "/CN=${subject}"`;
-                    await exec(`${startCmd} ${createCertCommand}`);
-                    if (await fs.exists(certPath)) {
-                        ConsoleWriter.info(`Certificate generated. Location is ${certPath}`);
-                        if (open) {
-                            await openCertFile(config);
-                        }
-                    }
-                    break;
-                case "win32":
-                    // for windows 7 and others
-                    // 6.1 - Windows 7
-                    const osVersion = os.release().split(".");
-                    if ((Number(osVersion[0]) === 6 && Number(osVersion[1]) === 1) || Number(osVersion[0]) < 6) {
-                        await removeCertFiles(certPath, keyPath, pfxPath);
-                        startCmd = "openssl";
-                        createCertCommand =
-                            `  req -newkey rsa:${keyLength}` +
-                                ` -nodes` +
-                                ` -keyout ${keyPath}` +
-                                ` -x509 ` +
-                                ` -days ${validPeriod} ` +
-                                ` -out ${certPath} ` +
-                                ` -subj "/CN=${subject}"`;
-                        await exec(`${startCmd} ${createCertCommand}`);
-                        if (await fs.exists(certPath)) {
-                            ConsoleWriter.info(`Certificate generated. Location is ${certPath}`);
-                            if (open) {
-                                await openCertFile(config);
-                            }
-                        }
-                        break;
-                    }
-                    let randomValues;
-                    if (crypto.getRandomValues !== undefined) {
-                        randomValues = crypto.getRandomValues(new Uint32Array(1));
-                    }
-                    else {
-                        randomValues = crypto.webcrypto.getRandomValues(new Uint32Array(1));
-                    }
-                    const passphrase = randomValues[0].toString().substring(2);
-                    config.server.passphrase = passphrase;
-                    fs.writeFileSync(path.join(rootPath, confPath), JSON.stringify(config));
-                    // for windows 8 / 8.1 / server 2012 R2 /
-                    if (Number(osVersion[0]) === 6 && (Number(osVersion[1]) === 2 || Number(osVersion[1]) === 3)) {
-                        // for 10
-                        createCertCommand = `$cert = ('Cert:\\CurrentUser\\My\\' + (` +
-                            `   New-SelfSignedCertificate ` +
-                            `       -DnsName localhost ` +
-                            `       -CertStoreLocation Cert:\\CurrentUser\\My ` +
-                            `   | select Thumbprint | ` +
-                            `   ForEach-Object { $_.Thumbprint.ToString() }).toString()); ` +
-                            `   Export-PfxCertificate -Cert $cert` +
-                            `       -FilePath '${pfxPath}' ` +
-                            `       -Password (ConvertTo-SecureString -String '${passphrase}' -Force -AsPlainText)`;
-                        await exec(`${startCmd} "${createCertCommand}"`);
-                    }
-                    else {
-                        // for window 10 / server 2016
-                        createCertCommand = `$cert = ('Cert:\\CurrentUser\\My\\' + (` +
-                            `   New-SelfSignedCertificate ` +
-                            `       -DnsName localhost ` +
-                            `       -HashAlgorithm ${algorithm} ` +
-                            `       -Type Custom ` +
-                            `       -Subject ${subject} ` +
-                            `       -KeyAlgorithm RSA ` +
-                            `       -KeyLength ${keyLength} ` +
-                            `       -KeyExportPolicy Exportable ` +
-                            `       -CertStoreLocation Cert:\\CurrentUser\\My ` +
-                            `       -NotAfter (get-date).AddDays(${validPeriod}) ` +
-                            `   | select Thumbprint | ` +
-                            `   ForEach-Object { $_.Thumbprint.ToString() }).toString()); ` +
-                            `   Export-PfxCertificate -Cert $cert` +
-                            `       -FilePath '${pfxPath}' ` +
-                            `       -Password (ConvertTo-SecureString -String '${passphrase}' -Force -AsPlainText)`;
-                        await exec(`${startCmd} "${createCertCommand}"`);
-                    }
-                    if (await fs.exists(pfxPath)) {
-                        ConsoleWriter.info(`Certificate generated. Location is ${pfxPath}. Passphrase is '${passphrase}'`);
+    if (!startCmd) {
+        ConsoleWriter.error(['Unknown platform. Please place a custom-generated certificate in:', certPath]);
+        return;
+    }
+    try {
+        let createCertCommand = "";
+        let passphrase = "";
+        fs.ensureDirSync(path.dirname(certPath));
+        switch (os.platform()) {
+            case "linux":
+            case "darwin":
+                createCertCommand =
+                    `  req -newkey rsa:${keyLength}` +
+                        ` -nodes` +
+                        ` -keyout ${keyPath}` +
+                        ` -x509 ` +
+                        ` -days ${validPeriod} ` +
+                        ` -out ${certPath} ` +
+                        ` -subj "/CN=${subject}"`;
+                await Promise.all([
+                    removeCertFiles(certPath, keyPath),
+                    exec(`${startCmd} ${createCertCommand}`)
+                ]);
+                if (await fs.exists(certPath)) {
+                    ConsoleWriter.info(`Certificate generated. Location is ${certPath}`);
+                    if (open) {
+                        await openCertFile();
                     }
-                    break;
-                default:
-                    ConsoleWriter.error('Unknown platform');
-            }
-        }
-        catch (e) {
-            if (e && e.message && e.message.indexOf("'openssl' is not recognized as an internal or external command") > 0) {
-                ConsoleWriter.warning('Create certificate error:');
-                ConsoleWriter.warning('OpenSSL is not installed or not available from command line');
-                ConsoleWriter.info('Install OpenSSL from https://www.openssl.org or https://wiki.openssl.org/index.php/Binaries');
-                ConsoleWriter.info('and try again');
-                ConsoleWriter.info('Read more at');
-                ConsoleWriter.info('https://github.com/Microsoft/PowerBI-visuals/blob/master/tools/CreateCertificate.md#manual');
-            }
-            else {
-                ConsoleWriter.error(['Create certificate error:', e]);
-            }
+                }
+                break;
+            case "win32":
+                passphrase = getRandomValues()[0].toString().substring(2);
+                createCertCommand = `$cert = ('Cert:\\CurrentUser\\My\\' + (` +
+                    `   New-SelfSignedCertificate ` +
+                    `       -DnsName localhost ` +
+                    `       -Type Custom ` +
+                    `       -Subject 'CN=${subject}' ` +
+                    `       -KeyAlgorithm RSA ` +
+                    `       -KeyLength ${keyLength} ` +
+                    `       -KeyExportPolicy Exportable ` +
+                    `       -CertStoreLocation Cert:\\CurrentUser\\My ` +
+                    `       -NotAfter (get-date).AddDays(${validPeriod}) ` +
+                    `   | select Thumbprint | ` +
+                    `   ForEach-Object { $_.Thumbprint.ToString() }).toString()); ` +
+                    `   Export-PfxCertificate -Cert $cert` +
+                    `       -FilePath '${pfxPath}' ` +
+                    `       -Password (ConvertTo-SecureString -String '${passphrase}' -Force -AsPlainText)`;
+                await Promise.all([
+                    removeCertFiles(certPath, keyPath, pfxPath),
+                    exec(`${startCmd} -Command "${createCertCommand}"`),
+                    savePassphrase(passphrase)
+                ]);
+                if (await fs.exists(pfxPath)) {
+                    ConsoleWriter.info(`Certificate generated. Location is ${pfxPath}. Passphrase is ${passphrase}`);
+                }
+                break;
+            default:
+                ConsoleWriter.error('Unknown platform');
+                break;
         }
     }
-    else {
-        ConsoleWriter.error(['Unknown platform. Please place a custom-generated certificate in:', certPath]);
+    catch (e) {
+        if (e && e.message && e.message.indexOf("'openssl' is not recognized as an internal or external command") > 0) {
+            ConsoleWriter.warning('Create certificate error:');
+            ConsoleWriter.warning('OpenSSL is not installed or not available from command line');
+            ConsoleWriter.info('Install OpenSSL from https://www.openssl.org or https://wiki.openssl.org/index.php/Binaries');
+            ConsoleWriter.info('and try again');
+            ConsoleWriter.info('Read more at');
+            ConsoleWriter.info('https://github.com/Microsoft/PowerBI-visuals/blob/master/tools/CreateCertificate.md#manual');
+        }
+        else {
+            ConsoleWriter.error(['Create certificate error:', e]);
+        }
     }
 }
-async function getCertFile(config, silent) {
-    if (typeof silent === "undefined") {
-        silent = false;
-    }
-    const cert = path.join(rootPath, config.server.certificate);
-    const pfx = path.join(rootPath, config.server.pfx);
-    if (await fs.exists(cert)) {
-        return cert;
+async function getCertFile(silent = false) {
+    const { certPath, pfxPath, passphrasePath } = secretFilesPath;
+    if (await fs.exists(certPath)) {
+        return certPath;
     }
-    if (await fs.exists(pfx)) {
-        if (config.server.passphrase) {
-            if (!silent) {
-                ConsoleWriter.info(`Use '${config.server.passphrase}' passphrase to install PFX certificate.`);
-            }
+    if (await fs.exists(pfxPath)) {
+        if (!silent && await fs.exists(passphrasePath)) {
+            const passphrase = await fs.readFile(passphrasePath, 'utf8');
+            ConsoleWriter.info(`Use '${passphrase}' passphrase to install PFX certificate.`);
         }
-        return pfx;
+        return pfxPath;
     }
     if (!silent) {
         ConsoleWriter.info('Certificate not found. Call `pbiviz install-cert` command to create the new certificate');
     }
     return null;
 }
-async function openCertFile(config) {
-    const certPath = await getCertFile(config);
-    if (!certPath) {
-        return null;
-    }
+async function openCertFile() {
     const openCmds = {
         linux: 'xdg-open',
         darwin: 'open',
         win32: 'powershell start'
     };
     const startCmd = openCmds[os.platform()];
-    if (startCmd) {
-        try {
-            await exec(`${startCmd} "${certPath}"`);
-        }
-        catch (e) {
-            ConsoleWriter.info(['Certificate path:', certPath]);
+    const certPath = await getCertFile();
+    try {
+        if (!startCmd || !certPath) {
+            throw new Error();
         }
+        await exec(`${startCmd} "${certPath}"`);
     }
-    else {
+    catch (e) {
         ConsoleWriter.info(['Certificate path:', certPath]);
     }
 }
-export async function removeCertFiles(certPath, keyPath, pfxPath) {
-    try {
-        await fs.unlink(certPath);
-    }
-    catch (e) {
-        if (!e.message.indexOf("no such file or directory")) {
-            throw e;
-        }
-    }
-    try {
-        await fs.unlink(keyPath);
-    }
-    catch (e) {
-        if (!e.message.indexOf("no such file or directory")) {
-            throw e;
+export async function removeCertFiles(...paths) {
+    paths.forEach(async (path) => {
+        try {
+            await fs.unlink(path);
         }
-    }
-    try {
-        await fs.unlink(pfxPath);
-    }
-    catch (e) {
-        if (!e.message.indexOf("no such file or directory")) {
-            throw e;
+        catch (e) {
+            if (!e.message.indexOf("no such file or directory")) {
+                throw e;
+            }
         }
-    }
-}
-async function getGlobalPbivizCerts(config) {
-    const options = {};
-    try {
-        const location = (await exec('npm ls -g powerbi-visuals-tools')).split("\n")[0];
-        const certPath = path.join(location, "node_modules", "powerbi-visuals-tools", config.server.certificate);
-        const keyPath = path.join(location, "node_modules", "powerbi-visuals-tools", config.server.privateKey);
-        const pfxPath = path.join(location, "node_modules", "powerbi-visuals-tools", config.server.pfx);
-        const globalPbivizConfig = path.join(location, "node_modules", "powerbi-visuals-tools", "config.json");
-        options.passphrase = fs.existsSync(globalPbivizConfig) && fs.readJSONSync(globalPbivizConfig).server.passphrase;
-        const CertFileVerified = await verifyCertFile(keyPath, certPath, pfxPath, options.passphrase);
-        options.cert = fs.existsSync(certPath) && certPath;
-        options.key = fs.existsSync(keyPath) && keyPath;
-        options.pfx = fs.existsSync(pfxPath) && CertFileVerified && pfxPath;
-    }
-    catch (err) {
-        ConsoleWriter.warning(`Global certificate error: ${err}`);
-    }
-    if (!options.cert && !options.pfx) {
-        ConsoleWriter.warning(`Global instance of valid pbiviz certificate not found.`);
-    }
-    return options;
+    });
 }
 export async function resolveCertificate() {
-    const config = readJsonFromRoot('config.json');
     const options = {};
-    const keyPath = path.join(rootPath, config.server.privateKey);
-    const certPath = path.join(rootPath, config.server.certificate);
-    const pfxPath = path.join(rootPath, config.server.pfx);
-    if (config.server.passphrase) {
-        options.passphrase = config.server.passphrase;
+    const { certPath, keyPath, pfxPath, passphrasePath } = secretFilesPath;
+    const isCertificateValid = await verifyCertFile(keyPath, certPath, pfxPath, passphrasePath);
+    if (!isCertificateValid) {
+        await createCertFile();
+    }
+    if (await fs.exists(passphrasePath)) {
+        options.passphrase = await fs.readFile(passphrasePath, 'utf8');
     }
     if (await fs.exists(keyPath)) {
         options.key = await fs.readFile(keyPath);
@@ -319,72 +215,24 @@ export async function resolveCertificate() {
     if (await fs.exists(pfxPath)) {
         options.pfx = await fs.readFile(pfxPath);
     }
-    const CertFileVerified = await verifyCertFile(keyPath, certPath, pfxPath, options.passphrase);
-    if ((!options.cert && !options.pfx) || !CertFileVerified) {
-        ConsoleWriter.warning("Local valid certificate not found.");
-        ConsoleWriter.info("Checking global instance of pbiviz certificate...");
-        const globalPbivizOptions = await getGlobalPbivizCerts(config);
-        if (!globalPbivizOptions.cert && !globalPbivizOptions.pfx) {
-            await createCertFile(config, true);
-            if (!(await getCertFile(config, true))) {
-                ConsoleWriter.error('Certificate wasn\'t created');
-                throw new Error("Call `pbiviz install-cert` command to create the new certificate");
-            }
-            else {
-                if (config.server.passphrase) {
-                    options.passphrase = config.server.passphrase;
-                }
-                if (await fs.exists(keyPath)) {
-                    options.key = await fs.readFile(keyPath);
-                }
-                if (await fs.exists(certPath)) {
-                    options.cert = await fs.readFile(certPath);
-                }
-                if (await fs.exists(pfxPath)) {
-                    options.pfx = await fs.readFile(pfxPath);
-                }
-            }
-        }
-        else {
-            // copy certs to local instance
-            ConsoleWriter.info("Copy server certificate from global instance of pbiviz...");
-            if (globalPbivizOptions.cert) {
-                await fs.copyFile(globalPbivizOptions.cert, path.join(rootPath, config.server.certificate));
-                options.certificate = config.server.certificate;
-            }
-            if (globalPbivizOptions.key) {
-                await fs.copyFile(globalPbivizOptions.key, path.join(rootPath, config.server.privateKey));
-                options.privateKey = config.server.privateKey;
-            }
-            if (globalPbivizOptions.pfx) {
-                await fs.copyFile(globalPbivizOptions.pfx, path.join(rootPath, config.server.pfx));
-                // need to pass whole file instead path to file
-                options.pfx = await fs.readFile(path.join(rootPath, config.server.pfx));
-                options.passphrase = globalPbivizOptions.passphrase;
-                // eslint-disable-next-line require-atomic-updates
-                config.server.passphrase = globalPbivizOptions.passphrase;
-            }
-            await fs.writeFile(path.join(rootPath, confPath), JSON.stringify(config));
-        }
-    }
     return options;
 }
-export async function verifyCertFile(keyPath, certPath, pfxPath, passphrase) {
-    let verifyCertDate;
+export async function verifyCertFile(keyPath, certPath, pfxPath, passphrasePath) {
+    let verifyCertDate = false;
     try {
         let endDateStr;
-        // For Windows OS:
         if (os.platform() === "win32") {
-            if (!fs.existsSync(pfxPath) || !passphrase) {
-                return false;
+            if (!fs.existsSync(pfxPath) || !fs.existsSync(passphrasePath)) {
+                throw new Error('PFX or passphrase file not found');
             }
-            const certStr = await exec(`powershell.exe (New-Object System.Security.Cryptography.X509Certificates.X509Certificate2('${pfxPath}','${passphrase}')).NotAfter.ToString('yyyy-MM-dd HH:mm:ss')`);
+            const passphrase = await fs.readFile(passphrasePath, 'utf8');
+            const command = `(New-Object System.Security.Cryptography.X509Certificates.X509Certificate2("${pfxPath}",'${passphrase}')).NotAfter.ToString('yyyy-MM-dd HH:mm:ss')`;
+            const certStr = await exec(command, { shell: 'powershell.exe' });
             endDateStr = certStr.trim();
         }
-        // For Linux and Mac/darwin OS:
         else if (os.platform() === "linux" || os.platform() === "darwin") {
-            if (!fs.existsSync(certPath)) {
-                return false;
+            if (!(await fs.exists(certPath))) {
+                throw new Error('Certificate file not found');
             }
             endDateStr = await exec(`openssl x509 -enddate -noout -in ${certPath} | cut -d = -f 2`);
         }
@@ -394,13 +242,22 @@ export async function verifyCertFile(keyPath, certPath, pfxPath, passphrase) {
             ConsoleWriter.info(`Certificate is valid.`);
         }
         else {
-            ConsoleWriter.warning(`Certificate is invalid!`);
-            removeCertFiles(certPath, keyPath, pfxPath);
+            throw new Error('Certificate is invalid');
         }
     }
     catch (err) {
         ConsoleWriter.warning(`Certificate verification error: ${err}`);
-        removeCertFiles(certPath, keyPath, pfxPath);
+        removeCertFiles(certPath, keyPath, pfxPath, passphrasePath);
     }
     return verifyCertDate;
 }
+const getRandomValues = () => {
+    if (crypto.getRandomValues !== undefined) {
+        return crypto.getRandomValues(new Uint32Array(1));
+    }
+    return crypto.webcrypto.getRandomValues(new Uint32Array(1));
+};
+const savePassphrase = async (passphrase) => {
+    const { passphrasePath } = secretFilesPath;
+    await fs.writeFileSync(passphrasePath, passphrase);
+};

package/lib/CommandManager.js

@@ -49,6 +49,7 @@ export default class CommandManager {
         const lintOptions = {
             verbose: options.verbose,
             fix: options.fix,
+            useDefault: options.useDefault
         };
         const visual = new VisualManager(rootPath).prepareVisual(options.pbivizFile);
         await visual.runLintValidation(lintOptions);

package/lib/LintValidator.js

@@ -1,37 +1,44 @@
 import { ESLint } from "eslint";
+import path from 'path';
+import fs from 'fs-extra';
 import ConsoleWriter from "./ConsoleWriter.js";
-import { fileExists, getRootPath } from "./utils.js";
+import { getRootPath } from "./utils.js";
 export class LintValidator {
     visualPath;
     rootPath;
+    isVerboseMode;
+    useDefault;
+    shouldFix;
     config;
-    defaultConfig;
     linterInstance;
-    constructor(fix = false) {
+    constructor({ verbose, fix, useDefault }) {
         this.visualPath = process.cwd();
         this.rootPath = getRootPath();
-        this.prepareConfig(fix);
+        this.isVerboseMode = verbose;
+        this.useDefault = useDefault;
+        this.shouldFix = fix;
+        this.prepareConfig();
         this.linterInstance = new ESLint(this.config);
     }
     /**
      * Runs lint validation in the visual folder
      */
-    async runLintValidation({ verbose, fix }) {
+    async runLintValidation() {
         ConsoleWriter.info("Running lint check...");
         // By default it will lint all files in the src of current working directory, but some files can be excluded in .eslintignore
-        const results = await this.linterInstance.lintFiles("src/**/*");
-        if (fix) {
+        const results = await this.linterInstance.lintFiles("src/");
+        if (this.shouldFix) {
             await this.fixErrors(results);
         }
-        await this.outputResults(results, verbose);
+        await this.outputResults(results);
         ConsoleWriter.info("Lint check completed.");
     }
     async fixErrors(results) {
         ConsoleWriter.info("Lint fixing errors...");
         await ESLint.outputFixes(results);
     }
-    async outputResults(results, verbose) {
-        if (verbose) {
+    async outputResults(results) {
+        if (this.isVerboseMode) {
             const formatter = await this.linterInstance.loadFormatter("stylish");
             const formattedResults = await formatter.format(results);
             console.log(formattedResults);
@@ -46,33 +53,42 @@ export class LintValidator {
             }
         }
     }
-    prepareConfig(fix) {
-        this.defaultConfig = {
-            overrideConfig: {
-                env: {
-                    browser: true,
-                    es6: true,
-                    es2022: true
-                },
-                plugins: [
-                    "powerbi-visuals"
-                ],
-                extends: [
-                    "plugin:powerbi-visuals/recommended"
-                ]
-            },
-            extensions: [".ts", ".tsx"],
-            resolvePluginsRelativeTo: this.rootPath,
-            useEslintrc: false,
-            fix
+    prepareConfig() {
+        const requiredConfig = {
+            extensions: [".js", ".jsx", ".ts", ".tsx"],
+            fix: this.shouldFix,
+            resolvePluginsRelativeTo: this.getPluginPath()
         };
-        const eslintrcExtensions = ['.json', '.js', '.ts'];
-        if (eslintrcExtensions.some(el => fileExists(this.visualPath, `.eslintrc${el}`))) {
-            this.config = { fix };
+        const eslintrcExtensions = ['.json', '.js', '.cjs', '.ts', ''];
+        if (!this.useDefault && eslintrcExtensions.some(el => fs.existsSync(path.join(this.visualPath, `.eslintrc${el}`)))) {
+            this.config = requiredConfig;
         }
         else {
-            ConsoleWriter.warning("No .eslintrc file found in the visual folder. Using default config.");
-            this.config = this.defaultConfig;
+            ConsoleWriter.warning("Using recommended eslint config.");
+            this.config = {
+                ...requiredConfig,
+                overrideConfig: {
+                    env: {
+                        browser: true,
+                        es6: true,
+                        es2022: true
+                    },
+                    plugins: [
+                        "powerbi-visuals"
+                    ],
+                    extends: [
+                        "plugin:powerbi-visuals/recommended"
+                    ]
+                },
+                useEslintrc: false,
+            };
         }
     }
+    getPluginPath() {
+        const pluginPaths = [
+            path.resolve(this.visualPath, "node_modules", "eslint-plugin-powerbi-visuals"),
+            path.resolve(this.rootPath, "node_modules", "eslint-plugin-powerbi-visuals")
+        ];
+        return pluginPaths.find(fs.existsSync);
+    }
 }

package/lib/VisualManager.js

@@ -68,9 +68,17 @@ export default class VisualManager {
         }
         return this;
     }
-    runLintValidation(options) {
-        const linter = new LintValidator(options.fix);
-        linter.runLintValidation(options);
+    async runLintValidation(options) {
+        try {
+            const linter = new LintValidator(options);
+            await linter.runLintValidation();
+        }
+        catch (error) {
+            ConsoleWriter.error("Can't run lint validation.");
+            if (options.verbose) {
+                ConsoleWriter.error(error.message);
+            }
+        }
     }
     createVisualInstance() {
         this.capabilities = readJsonFromVisual("capabilities.json", this.basePath);

package/lib/utils.js

@@ -22,7 +22,7 @@ export function getRootPath() {
     const pathToDirectory = fileURLToPath(import.meta.url);
     return path.join(pathToDirectory, "..", "..");
 }
-export function readFileFromRoot(filePath) {
+function readFileFromRoot(filePath) {
     return fs.readFileSync(path.join(getRootPath(), filePath), "utf8");
 }
 export function readJsonFromRoot(filePath) {
@@ -31,6 +31,3 @@ export function readJsonFromRoot(filePath) {
 export function readJsonFromVisual(filePath, visualPath) {
     return JSON.parse(fs.readFileSync(path.join(visualPath ?? process.cwd(), filePath), "utf8"));
 }
-export function fileExists(pathToFile, fileName) {
-    return fs.existsSync(path.join(pathToFile, fileName));
-}

package/lib/webpack.config.js

@@ -72,6 +72,7 @@ const webpackConfig = {
         "powerbi-visuals-api": 'null'
     },
     resolve: {
+        symlinks: false,
         extensions: ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.css'],
         modules: ['node_modules', path.resolve(rootPath, 'node_modules')],
         fallback: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powerbi-visuals-tools",
-  "version": "5.4.2",
+  "version": "5.5.0",
   "description": "Command line tool for creating and publishing visuals for Power BI",
   "main": "./bin/pbiviz.js",
   "type": "module",
@@ -29,7 +29,7 @@
   },
   "homepage": "https://github.com/Microsoft/PowerBI-visuals-tools#readme",
   "dependencies": {
-    "@typescript-eslint/parser": "^6.17.0",
+    "@typescript-eslint/parser": "^7.12.0",
     "assert": "^2.1.0",
     "async": "^3.2.5",
     "browserify-zlib": "^0.2.0",
@@ -40,22 +40,22 @@
     "console-browserify": "^1.2.0",
     "constants-browserify": "^1.0.0",
     "crypto-browserify": "^3.12.0",
-    "css-loader": "^6.8.1",
+    "css-loader": "^6.11.0",
     "domain-browser": "^5.7.0",
     "events": "^3.3.0",
     "extra-watch-webpack-plugin": "^1.0.3",
     "fs-extra": "^11.2.0",
     "https-browserify": "^1.0.0",
-    "inline-source-map": "^0.6.2",
+    "inline-source-map": "^0.6.3",
     "json-loader": "0.5.7",
     "jszip": "^3.10.1",
     "less": "^4.2.0",
-    "less-loader": "^11.1.4",
+    "less-loader": "^12.2.0",
     "lodash.clonedeep": "4.5.0",
     "lodash.defaults": "4.2.0",
     "lodash.isequal": "4.5.0",
     "lodash.ismatch": "^4.4.0",
-    "mini-css-extract-plugin": "^2.7.6",
+    "mini-css-extract-plugin": "^2.9.0",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
     "powerbi-visuals-webpack-plugin": "4.1.0",
@@ -74,17 +74,17 @@
     "url": "^0.11.3",
     "util": "^0.12.5",
     "vm-browserify": "^1.1.2",
-    "webpack": "^5.89.0",
-    "webpack-bundle-analyzer": "4.10.1",
-    "webpack-dev-server": "^4.15.1"
+    "webpack": "^5.91.0",
+    "webpack-bundle-analyzer": "4.10.2",
+    "webpack-dev-server": "^4.15.2"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.17.0",
-    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "eslint": "^8.57.0",
     "eslint-plugin-powerbi-visuals": "^0.8.1",
     "jasmine": "5.1.0",
     "jasmine-spec-reporter": "7.0.0",
-    "semver": "7.5.4",
+    "semver": "7.6.2",
     "tree-kill": "1.2.2",
     "webpack-cli": "^5.1.4"
   },

package/certs/PowerBICustomVisualTest_private.key

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCogcnCQF7icDMN
-Ot76I0U7W33z/d4kDirk525CT+uehSAEFqoNuz6fOXIsjDIz4nYrXusmcX2w3XTt
-SJr9vxvia437lE6wiNUUTmD8j2Xin3pjPa3j203suQQ+WZnbomidBDDgPTuEnqtY
-v/BDnT6i0DBtFu22CRDgdUK/zJRW6pJ1jikHDMJeEplaZXMYVTC3ZvyZXPQfvWzV
-EoIh4root7GyWOEPUuhZf2BfS2hP7ELTBG+EMFw5j7grO1uiNVy68pSMPTSv92Hn
-QmlGARlVsXlpCwyjHbmGU6UkHiP+LeMIKnSPIzbaHFz1TXBp93Tel/YyglSGx7UD
-eZr8Su4NAgMBAAECggEAAKfMluaifGyTctVebxqDlza7icPKHKLK5qLm9/d+nn7h
-W6T/yDMtea6nc69WfvC+N1xCO3qM0q+os2vgGC5yfBsztmaZgAvd7XamllvF3i+X
-n+0O2iz6tfnzH32Jl796xERzHssJnJaq2GQIdXCWN9vFUQYsc4rkxWmayTjstxRn
-CK0cEA42ObwABm1PXzkF1f4yX0K0EKxu+IgWcab2QM1QytuUXy5g3aqSgvHltfyu
-7sAsvwbR0eDNT5errekwXp6P5p3Z32wGqtGPITvhXrDRO9dwdIqriYXONUeSjuUQ
-QQWcXMjUXjrWRmXeYVUT29qpA5RsTYB4ZPyKuZlQ4wKBgQDB8siSdtGRD624nDYU
-M+oRpCivJnIOXXTTZwt0LaHWepwDK/9DTlCGjKiBZ018arcDfEwCzPqKlkq9c4/k
-jCG94o+wrRNLmA8nJsDX/VzCUixsvypvnpmlTNL3gZuPrpcODJwi1GCnll9BKKrx
-euzPAprFiIl11vL9UvctxqHDfwKBgQDeaz5/hB7K7ns2Pr6+QjOwGE2lADgb90rk
-ovnz5BDIX5FdlYqp1FcL5VxlFZBg7evzFenG9p/F5A/ILtRvsCOMrNgAvg8YO17+
-lYdJMGMte7FPbU7ZbrEwXSqWTyqWbIRkSF6p/UZjKdqVkvbI5kLoD9Rv5yX2N7Kt
-wzkNBf3kcwKBgQCrH2uYzv1Y4FyG5k1Qxf1gU1cSMvmvcwYBAIo6l4iTlNrScZ9n
-41FpZfHHOz5C6GVRzfnC/tiQLssDHVN4c6vRvnTJjevYZvH3uVmtOP7+9UH9MS5g
-Da/DCWWau+BlhcYBv16D3J7rPuIMu7UYGz2V6NZmM3IVZvI+UVWGLhvMQQKBgQDV
-mvFezag1BGvYYNIXLsUtLWoEOP2p/gkzI0Ih9LoZdY7J7cBJ8d/XUOM3QUpzjIu5
-3SWzK0+uYaS2gCMNUIATrjuUGvOsNfi5TymqJIpbOBvFSBkdwKzy4cbwq/8ekAFl
-vgsL/m4G9j8yvv27W0iOTgWbosZWfI9hScgUtdhr+QKBgFHglSD6HJO3KMYzVYHQ
-UaZWBs3vRY651vd9uIa4+SD09++t8wpSnOw8BAVkC0H4B2u/H+uXqLkBjta4QlHn
-6++Lg73bPmYVTvGwFpNeqaYmn2huP1vVr5Vayzjg9l0hoDCFnsFZMyfenhjlOCbm
-p2AItkHbaog5a/rLjV58yEXA
------END PRIVATE KEY-----

package/certs/PowerBICustomVisualTest_public.crt

@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDCTCCAfGgAwIBAgIURq4z8w69FkvegPibl5y4/gy6j0gwDQYJKoZIhvcNAQEL
-BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTI0MDIxMjE5MDE1MVoXDTI1MDIx
-MTE5MDE1MVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF
-AAOCAQ8AMIIBCgKCAQEAqIHJwkBe4nAzDTre+iNFO1t98/3eJA4q5OduQk/rnoUg
-BBaqDbs+nzlyLIwyM+J2K17rJnF9sN107Uia/b8b4muN+5ROsIjVFE5g/I9l4p96
-Yz2t49tN7LkEPlmZ26JonQQw4D07hJ6rWL/wQ50+otAwbRbttgkQ4HVCv8yUVuqS
-dY4pBwzCXhKZWmVzGFUwt2b8mVz0H71s1RKCIeK6KLexsljhD1LoWX9gX0toT+xC
-0wRvhDBcOY+4KztbojVcuvKUjD00r/dh50JpRgEZVbF5aQsMox25hlOlJB4j/i3j
-CCp0jyM22hxc9U1wafd03pf2MoJUhse1A3ma/EruDQIDAQABo1MwUTAdBgNVHQ4E
-FgQUP6Yxfkh8EYZu8C30+jj+4mjOJQwwHwYDVR0jBBgwFoAUP6Yxfkh8EYZu8C30
-+jj+4mjOJQwwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEANQdr
-HnpKoC7vgYEXEsnrZNRqAlTCUBSZlsBP9wvUCAS2lgZJTeNKiqONg7KlfTR0ob1P
-MqeqyYxMuEGYRmIglZPORvX7dN3bl/l6860RTV+ctzvVGszvOFGAUZ7YV2nEcTaR
-KTg17huZ9E9apt4P0wT5edUcAQdF10WuOuCZVs0jgIlLv1EOkzkB6QJLu/GGhaYH
-sBf6i0FBRnDtcBw9/20xIUqXFQb56bL0X+6TWOfDMTKcl99KrlHFtg2O0tFInNSc
-0e10FLES58gKb2w7q1UyHpWWDLjCyP3SqB4lcpFaKYHUio0IvvFME3PfJMcNjurL
-X0ge18jFIOnvUvOiLw==
------END CERTIFICATE-----