powerbi-visuals-tools 7.0.0 → 7.0.1

package/Changelog.md

@@ -2,6 +2,10 @@
 
 This page contains information about changes to the PowerBI Visual Tools (pbiviz).
 
+## 7.0.1
+* Fixed issue with missing `lib/*` files in latest versions.
+* Updated packages
+
 ## 7.0.0
 * **BREAKING CHANGE**: Removed Node.js polyfills from webpack configuration for improved security and reduced bundle size. Node.js modules (crypto, buffer, stream, etc.) are no longer automatically available in the browser environment.
 * Removed browserify polyfill packages from dependencies (assert, buffer, crypto-browserify, console-browserify, constants-browserify, domain-browser, events, https-browserify, os-browserify, path-browserify, process, punycode, querystring-es3, readable-stream, stream-browserify, stream-http, string_decoder, timers-browserify, tty-browserify, url, util, vm-browserify, browserify-zlib)

package/lib/CertificateTools.js

@@ -0,0 +1,262 @@
+/*
+ *  Power BI Visual CLI
+ *
+ *  Copyright (c) Microsoft Corporation
+ *  All rights reserved.
+ *  MIT License
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the ""Software""), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+"use strict";
+import { exec as nodeExec } from 'child_process';
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import crypto from "crypto";
+import { readJsonFromRoot } from './utils.js';
+import ConsoleWriter from './ConsoleWriter.js';
+const certSafePeriod = 1000 * 60 * 60 * 24; // 24 hours
+const config = await 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) => {
+        const defaultCallback = (err, stdout, stderr) => {
+            if (err) {
+                reject(stderr);
+            }
+            resolve(stdout);
+        };
+        nodeExec(command, options, callback ? callback : defaultCallback);
+    });
+}
+export async function createCertificate() {
+    const certPath = await getCertFile(true);
+    if (!certPath) {
+        ConsoleWriter.error("Certificate not found. The new certificate will be generated");
+        await createCertFile(true);
+    }
+    else {
+        await openCertFile();
+    }
+}
+export async function createCertFile(open = false) {
+    ConsoleWriter.info(`Generating a new certificate...`);
+    const subject = "localhost";
+    const keyLength = 2048;
+    const validPeriod = 365;
+    const { certPath, keyPath, pfxPath } = secretFilesPath;
+    const openCmds = {
+        linux: 'openssl',
+        darwin: 'openssl',
+        win32: 'pwsh'
+    };
+    let startCmd = openCmds[os.platform()];
+    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;
+            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;
+        }
+    }
+    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(silent = false) {
+    const { certPath, pfxPath, passphrasePath } = secretFilesPath;
+    if (await fs.exists(certPath)) {
+        return certPath;
+    }
+    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 pfxPath;
+    }
+    if (!silent) {
+        ConsoleWriter.info('Certificate not found. Call `pbiviz install-cert` command to create the new certificate');
+    }
+    return null;
+}
+async function openCertFile() {
+    const openCmds = {
+        linux: 'xdg-open',
+        darwin: 'open',
+        win32: 'powershell start'
+    };
+    const startCmd = openCmds[os.platform()];
+    const certPath = await getCertFile();
+    try {
+        if (!startCmd || !certPath) {
+            throw new Error();
+        }
+        await exec(`${startCmd} "${certPath}"`);
+    }
+    catch (e) {
+        ConsoleWriter.info(['Certificate path:', certPath]);
+    }
+}
+export async function removeCertFiles(...paths) {
+    paths.forEach(async (path) => {
+        try {
+            await fs.unlink(path);
+        }
+        catch (e) {
+            if (!e.message.indexOf("no such file or directory")) {
+                throw e;
+            }
+        }
+    });
+}
+export async function resolveCertificate() {
+    const options = {};
+    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);
+    }
+    if (await fs.exists(certPath)) {
+        options.cert = await fs.readFile(certPath);
+    }
+    if (await fs.exists(pfxPath)) {
+        options.pfx = await fs.readFile(pfxPath);
+    }
+    return options;
+}
+export async function verifyCertFile(keyPath, certPath, pfxPath, passphrasePath) {
+    let verifyCertDate = false;
+    try {
+        let endDateStr;
+        if (os.platform() === "win32") {
+            if (!fs.existsSync(pfxPath) || !fs.existsSync(passphrasePath)) {
+                throw new Error('PFX or passphrase file not found');
+            }
+            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();
+        }
+        else if (os.platform() === "linux" || os.platform() === "darwin") {
+            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`);
+        }
+        const endDate = Date.parse(endDateStr);
+        verifyCertDate = (endDate - Date.now()) > certSafePeriod;
+        if (verifyCertDate) {
+            ConsoleWriter.info(`Certificate is valid.`);
+        }
+        else {
+            throw new Error('Certificate is invalid');
+        }
+    }
+    catch (err) {
+        ConsoleWriter.warning(`Certificate verification error: ${err}`);
+        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

@@ -0,0 +1,75 @@
+import { createCertificate } from './CertificateTools.js';
+import ConsoleWriter from './ConsoleWriter.js';
+import VisualManager from './VisualManager.js';
+export default class CommandManager {
+    static async start(options, rootPath) {
+        const webpackOptions = {
+            devMode: true,
+            devtool: "inline-source-map",
+            generateResources: true,
+            generatePbiviz: false,
+            minifyJS: false,
+            minify: false,
+            devServerPort: options.port,
+            stats: options.stats,
+            skipApiCheck: options.skipApi,
+            allLocales: options.allLocales,
+            pbivizFile: options.pbivizFile,
+        };
+        const visualManager = new VisualManager(rootPath);
+        await visualManager.prepareVisual(options.pbivizFile);
+        await visualManager.validateVisual();
+        await visualManager.initializeWebpack(webpackOptions);
+        visualManager.startWebpackServer(options.drop);
+    }
+    static async lint(options, rootPath) {
+        const visualManager = new VisualManager(rootPath);
+        await visualManager.prepareVisual();
+        await visualManager.runLintValidation(options);
+    }
+    static async package(options, rootPath) {
+        if (!options.pbiviz && !options.resources) {
+            ConsoleWriter.error('Nothing to build. Cannot use --no-pbiviz without --resources');
+            process.exit(1);
+        }
+        const webpackOptions = {
+            devMode: false,
+            generateResources: options.resources,
+            generatePbiviz: options.pbiviz,
+            minifyJS: options.minify,
+            minify: options.minify,
+            compression: options.compression,
+            stats: options.stats,
+            skipApiCheck: options.skipApi,
+            allLocales: options.allLocales,
+            pbivizFile: options.pbivizFile,
+            certificationAudit: options.certificationAudit,
+            certificationFix: options.certificationFix,
+        };
+        const lintOptions = {
+            verbose: options.verbose,
+            fix: options.fix,
+        };
+        const visualManager = new VisualManager(rootPath);
+        const visual = await visualManager.prepareVisual(options.pbivizFile);
+        await visual.runLintValidation(lintOptions);
+        await visual.validateVisual(options.verbose);
+        await visual.initializeWebpack(webpackOptions)
+            .then(manager => manager.generatePackage(options.verbose));
+    }
+    static new({ force, template }, name, rootPath) {
+        const generateOptions = {
+            force: force,
+            template: template
+        };
+        VisualManager.createVisual(rootPath, name, generateOptions);
+    }
+    static async info(rootPath) {
+        const visualManager = new VisualManager(rootPath);
+        await visualManager.prepareVisual();
+        await visualManager.displayInfo();
+    }
+    static async installCert() {
+        await createCertificate();
+    }
+}

package/lib/ConsoleWriter.js

@@ -0,0 +1,188 @@
+/*
+ *  Power BI Visual CLI
+ *
+ *  Copyright (c) Microsoft Corporation
+ *  All rights reserved.
+ *  MIT License
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the ""Software""), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+"use strict";
+import chalk from 'chalk';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getRootPath } from './utils.js';
+const preferredChalk = os.platform() === 'darwin' ? chalk.bold : chalk;
+function prependLogTag(tag, args) {
+    return [tag].concat(args);
+}
+export default class ConsoleWriter {
+    /** Causes the terminal to beep */
+    static beep() {
+        process.stdout.write("\x07");
+    }
+    /** Outputs a blank line */
+    static blank() {
+        console.info(preferredChalk.reset(' '));
+    }
+    /**
+     * Outputs arguments with the "done" tag / colors
+     *
+     * @param {array} arguments - arguments passed through to console.info
+     */
+    static done(args) {
+        const tag = preferredChalk.bgGreen(' done  ');
+        console.info.apply(this, prependLogTag(tag, args));
+    }
+    /**
+     * Outputs arguments with the "info" tag / colors
+     *
+     * @param {array} args - arguments passed through to console.info
+     */
+    static info(args) {
+        const tag = preferredChalk.bgCyan(' info  ');
+        console.info.apply(this, prependLogTag(tag, args));
+    }
+    /**
+     * Outputs arguments with the "warn" tag / colors
+     *
+     * @param {array} args - arguments passed through to console.warn
+     */
+    static warning(args) {
+        const tag = preferredChalk.bgYellow.black(' warn  ');
+        console.warn.apply(this, prependLogTag(tag, args));
+    }
+    /**
+     * Outputs arguments with the "error" tag / colors
+     *
+     * @param {array} args - arguments passed through to console.error
+     */
+    static error(args) {
+        const tag = preferredChalk.bgRed(' error ');
+        console.error.apply(this, prependLogTag(tag, args));
+    }
+    /**
+     * Outputs an object as a table
+     *
+     * @param {string} data - object to output
+     * @param {number} [depthLimit=Infinity] - limit the number of levels to recurse
+     * @param {string} [keyPrefix=''] - text to prepend to each key
+     */
+    static infoTable(data, depthLimit, keyPrefix) {
+        if (!data) {
+            return;
+        }
+        const limit = typeof depthLimit === 'undefined' ? Infinity : depthLimit;
+        for (const key in data) {
+            const item = data[key];
+            const itemKey = (keyPrefix || '') + key;
+            if (limit > 1 && typeof item === 'object' && !Array.isArray(item)) {
+                ConsoleWriter.infoTable(item, limit - 1, itemKey + '.');
+            }
+            else {
+                ConsoleWriter.infoTableRow(itemKey, item);
+            }
+        }
+    }
+    /**
+     * Outputs a table row with even spaced keys
+     *
+     * @param {string} key - title of this row
+     * @param {string} value - value for this row
+     * @param {number} [keyWidth=30] - width used for padding of the key column
+     */
+    static infoTableRow(key, value, keyWidth) {
+        const width = keyWidth || 30;
+        const padding = Math.max(0, width - key.length);
+        const paddedKey = preferredChalk.bold(key) + (new Array(padding)).join('.');
+        ConsoleWriter.info([paddedKey, value]);
+    }
+    /**
+     * Outputs formatted errors
+     *
+     * @param {Array<Error>} errors
+     */
+    static formattedErrors(errors) {
+        if (errors && Array.isArray(errors)) {
+            errors.forEach((error) => {
+                if (!error) {
+                    return;
+                }
+                const tag = error.type ? preferredChalk.bold(error.type.toUpperCase()) : 'UNKNOWN';
+                const file = error.filename ? preferredChalk.bgWhite.black(` ${error.filename} `) + ':' : '';
+                const position = (error.line && error.column) ? preferredChalk.cyan(`(${error.line},${error.column})`) : '';
+                const message = error.message || '';
+                ConsoleWriter.error([tag, `${file} ${position} ${message}`]);
+            });
+        }
+        else {
+            ConsoleWriter.error(['UNKNOWN', errors]);
+        }
+    }
+    /**
+     * Outputs ascii art of the PowerBI logo
+     */
+    static getLogoVisualization() {
+        return fs.readFileSync(path.join(getRootPath(), 'assets', 'logo.txt')).toString();
+    }
+    /**
+     * Outputs validation log from PBIVIZ package checking
+     */
+    static validationLog(log) {
+        // api/js/css/pkg
+        const filterChecks = (attrCB, propCB) => {
+            for (const checkname in log) {
+                if (checkname !== 'valid') {
+                    const checkpoint = log[checkname];
+                    ConsoleWriter[checkpoint.error.length ? 'info' : 'done'](checkpoint.check);
+                    attrCB(checkpoint, propCB);
+                }
+            }
+        };
+        // error/message/ok
+        const filterCheckAttrs = (checkpoint, propCB) => {
+            for (const propName in checkpoint) {
+                if (propName !== 'message') {
+                    const prop = checkpoint[propName];
+                    if (typeof (prop) === 'object' && prop.length) {
+                        propCB(prop, propName);
+                    }
+                }
+            }
+        };
+        // col/line/text
+        const filterAttrProps = (props, propName) => {
+            props.forEach((opt) => {
+                const result = [];
+                for (const key in opt) {
+                    result.push(opt[key]);
+                }
+                if (result.length) {
+                    ConsoleWriter[propName === 'error' ? 'error' : 'warn'](result.join(' --> '));
+                }
+            });
+        };
+        filterChecks(filterCheckAttrs, filterAttrProps);
+        const type = log.valid ? 'done' : 'error';
+        const text = log.valid ? 'Valid package' : 'Invalid package';
+        ConsoleWriter.blank();
+        ConsoleWriter[type](text);
+    }
+}

package/lib/FeatureManager.js

@@ -0,0 +1,43 @@
+import { Severity } from "./features/FeatureTypes.js";
+import * as features from "./features/index.js";
+export var Status;
+(function (Status) {
+    Status[Status["Success"] = 0] = "Success";
+    Status[Status["Error"] = 1] = "Error";
+})(Status || (Status = {}));
+export class FeatureManager {
+    features = Object.keys(features).map(key => features[key]);
+    validate(stage, sourceInstance) {
+        const result = {
+            status: Status.Success,
+            logs: {
+                errors: [],
+                warnings: [],
+                info: [],
+                deprecation: []
+            }
+        };
+        this.features
+            .filter(feature => feature.stage == stage)
+            .filter(feature => feature.visualFeatureType & sourceInstance.visualFeatureType)
+            .filter(feature => !feature.isSupported(sourceInstance))
+            .forEach(({ errorMessage, severity }) => {
+            switch (severity) {
+                case Severity.Error:
+                    result.status = Status.Error;
+                    result.logs.errors.push(errorMessage);
+                    break;
+                case Severity.Warning:
+                    result.logs.warnings.push(errorMessage);
+                    break;
+                case Severity.Info:
+                    result.logs.info.push(errorMessage);
+                    break;
+                case Severity.Deprecation:
+                    result.logs.deprecation.push(errorMessage);
+                    break;
+            }
+        });
+        return result;
+    }
+}

package/lib/LintValidator.js

@@ -0,0 +1,61 @@
+import { ESLint } from "eslint";
+import powerbiPlugin from 'eslint-plugin-powerbi-visuals';
+import ConsoleWriter from "./ConsoleWriter.js";
+import { getRootPath } from "./utils.js";
+export class LintValidator {
+    visualPath;
+    rootPath;
+    isVerboseMode;
+    shouldFix;
+    config;
+    linterInstance;
+    constructor({ verbose, fix }) {
+        this.visualPath = process.cwd();
+        this.rootPath = getRootPath();
+        this.isVerboseMode = verbose;
+        this.shouldFix = fix;
+        this.prepareConfig();
+        this.linterInstance = new ESLint(this.config);
+    }
+    /**
+     * Runs lint validation in the visual folder
+     */
+    async runLintValidation() {
+        ConsoleWriter.info("Running lint check...");
+        // By default it will lint all files in the src of current working directory
+        const results = await this.linterInstance.lintFiles("src/");
+        if (this.shouldFix) {
+            await this.fixErrors(results);
+        }
+        await this.outputResults(results);
+        ConsoleWriter.info("Lint check completed.");
+    }
+    async fixErrors(results) {
+        ConsoleWriter.info("Lint fixing errors...");
+        await ESLint.outputFixes(results);
+    }
+    async outputResults(results) {
+        if (this.isVerboseMode) {
+            const formatter = await this.linterInstance.loadFormatter("stylish");
+            const formattedResults = await formatter.format(results);
+            console.log(formattedResults);
+        }
+        else {
+            const filteredResults = ESLint.getErrorResults(results);
+            // get total amount of errors and warnings in all elements of filteredResults
+            const totalErrors = filteredResults.reduce((acc, curr) => acc + curr.errorCount, 0);
+            const totalWarnings = filteredResults.reduce((acc, curr) => acc + curr.warningCount, 0);
+            if (totalErrors > 0 || totalWarnings > 0) {
+                ConsoleWriter.error(`Linter found ${totalErrors} errors and ${totalWarnings} warnings. Run with --verbose flag to see details.`);
+            }
+        }
+    }
+    prepareConfig() {
+        ConsoleWriter.warning("Using recommended eslint config.");
+        this.config = {
+            overrideConfig: powerbiPlugin.configs.recommended,
+            overrideConfigFile: true,
+            fix: this.shouldFix,
+        };
+    }
+}

package/lib/Package.js

@@ -0,0 +1,46 @@
+/*
+ *  Power BI Visual CLI
+ *
+ *  Copyright (c) Microsoft Corporation
+ *  All rights reserved.
+ *  MIT License
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the ""Software""), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+"use strict";
+import isMatch from "lodash.ismatch";
+/**
+ * Represents an instance of a visual package based on file path
+ */
+export default class Package {
+    sourceCode;
+    capabilities;
+    visualFeatureType;
+    constructor(sourceCode, capabilities, visualFeatureType) {
+        this.sourceCode = sourceCode;
+        this.capabilities = capabilities;
+        this.visualFeatureType = visualFeatureType;
+    }
+    contain(keyword) {
+        return this.sourceCode.includes(keyword);
+    }
+    isCapabilityEnabled(expectedObject) {
+        return isMatch(this.capabilities, expectedObject);
+    }
+}