powerbi-visuals-tools 7.0.0 → 7.0.1

package/lib/TemplateFetcher.js

@@ -0,0 +1,111 @@
+import { createFolder, download, readJsonFromRoot } from './utils.js';
+import ConsoleWriter from './ConsoleWriter.js';
+import JSZip from 'jszip';
+import VisualGenerator from "./VisualGenerator.js";
+import { exec } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+const config = await readJsonFromRoot('config.json');
+export default class TemplateFetcher {
+    templateName;
+    visualName;
+    folderName;
+    apiVersion;
+    constructor(templateName, visualName, apiVersion) {
+        this.templateName = templateName;
+        this.visualName = visualName;
+        this.folderName = `${this.visualName}`;
+        this.apiVersion = apiVersion;
+    }
+    fetch() {
+        const folder = createFolder.call(this, this.folderName);
+        download.call(this, config.visualTemplates[this.templateName], path.join(folder, "template.zip"))
+            .then(this.extractFiles.bind(this))
+            .then(this.removeZipFile.bind(this))
+            .then(this.setVisualGUID.bind(this))
+            .then(this.setApiVersion.bind(this))
+            .then(this.runNpmInstall.bind(this))
+            .then(this.showNextSteps.bind(this));
+    }
+    async removeZipFile() {
+        const folder = path.join("./", this.folderName);
+        const fileName = path.join(folder, "template.zip");
+        await fs.unlink(`.${path.sep}${fileName}`, (err) => {
+            if (err) {
+                ConsoleWriter.warning(`.${path.sep}${fileName} was not deleted`);
+            }
+        });
+    }
+    async extractFiles(file) {
+        const filePath = path.join(process.cwd(), file.path);
+        const buffer = await fs.readFile(filePath);
+        const zip = await JSZip.loadAsync(buffer);
+        const filesList = Object.keys(zip.files);
+        for (const filename of filesList) {
+            if (filename[filename.length - 1] === "/") {
+                // generate folders                            for exclude parent folder
+                const dest = path.join(path.dirname(filePath), path.join(filename, ".."));
+                await fs.ensureDir(dest);
+            }
+            else {
+                // write files into dirs                       for exclude parent folder
+                const dest = path.join(path.dirname(filePath), path.join(path.dirname(filename), "..", filename.split("/").pop() ?? ""));
+                const content = await zip.file(filename)?.async('nodebuffer');
+                await fs.writeFile(dest, content);
+            }
+        }
+    }
+    async setApiVersion() {
+        if (!this.apiVersion) {
+            return;
+        }
+        ConsoleWriter.info(`Set Visual API to ${this.apiVersion}`);
+        const packageJsonFile = path.join(process.cwd(), this.folderName, "package.json");
+        const packageJson = await fs.readJson(packageJsonFile);
+        if (packageJson.devDependencies && packageJson.devDependencies["powerbi-visuals-api"]) {
+            packageJson.devDependencies["powerbi-visuals-api"] = `~${this.apiVersion}`;
+        }
+        if (packageJson.dependencies && packageJson.dependencies["powerbi-visuals-api"]) {
+            packageJson.dependencies["powerbi-visuals-api"] = `~${this.apiVersion}`;
+        }
+        await fs.writeJSON(packageJsonFile, packageJson);
+    }
+    async setVisualGUID() {
+        const pbivizJsonFile = path.join(process.cwd(), this.folderName, "pbiviz.json");
+        const pbivizJson = await fs.readJson(pbivizJsonFile);
+        pbivizJson.visual.guid = this.visualName + VisualGenerator.generateVisualGuid();
+        await fs.writeJSON(pbivizJsonFile, pbivizJson);
+    }
+    runNpmInstall() {
+        return new Promise((resolve, reject) => {
+            ConsoleWriter.info("Installing packages...");
+            process.chdir(this.folderName);
+            // const { stdout, stderr } = await exec('ls');
+            const child = exec('npm install', (error, stdout, stderr) => {
+                if (error) {
+                    ConsoleWriter.error(error.stack);
+                    ConsoleWriter.error(`Error code: ${error.code}`);
+                    ConsoleWriter.error(`Signal received: ${error.signal}`);
+                }
+                ConsoleWriter.warning(stderr);
+                ConsoleWriter.info(stdout);
+                resolve(true);
+            });
+            child.on("error", (er) => {
+                ConsoleWriter.error(er);
+                reject();
+            });
+            child.on("exit", (code) => {
+                if (code !== 0) {
+                    ConsoleWriter.error(`npm install stopped with code ${code}`);
+                    reject();
+                }
+            });
+        });
+    }
+    showNextSteps() {
+        ConsoleWriter.blank();
+        ConsoleWriter.info("Run `npm run start` to start visual development");
+        ConsoleWriter.info("Run `npm run package` to create visual package");
+    }
+}

package/lib/Visual.js

@@ -0,0 +1,29 @@
+import { compareVersions } from "compare-versions";
+import { VisualFeatureType } from "./features/FeatureTypes.js";
+export class Visual {
+    visualFeatureType;
+    capabilities;
+    config;
+    visualVersion;
+    constructor(capabilities, config) {
+        this.capabilities = capabilities;
+        this.config = config;
+        this.visualFeatureType = this.getVisualFeatureType();
+        this.visualVersion = config.visual.version;
+    }
+    doesAPIVersionMatch(minAPIversion) {
+        return compareVersions(this.config.apiVersion ?? minAPIversion, minAPIversion) !== -1;
+    }
+    isVisualVersionValid(length) {
+        return this.visualVersion.split(".").length === length;
+    }
+    getVisualFeatureType() {
+        const isMatrixSupported = this.capabilities?.dataViewMappings?.some(dataView => dataView.matrix);
+        const isSlicer = Boolean(this.capabilities?.objects?.general?.properties?.filter?.type?.filter);
+        let type = isSlicer ? VisualFeatureType.Slicer : VisualFeatureType.NonSlicer;
+        if (isMatrixSupported) {
+            type = type | VisualFeatureType.Matrix;
+        }
+        return type;
+    }
+}

package/lib/VisualGenerator.js

@@ -0,0 +1,221 @@
+/*
+ *  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 crypto from 'crypto';
+import { getRootPath, readJsonFromRoot } from './utils.js';
+import { compareVersions } from "compare-versions";
+import fs from 'fs-extra';
+import lodashDefaults from 'lodash.defaults';
+import path from 'path';
+import template from '../templates/pbiviz-json-template.js';
+const config = await readJsonFromRoot('config.json');
+const VISUAL_TEMPLATES_PATH = path.join(getRootPath(), config.templates.visuals);
+const API_VERSION = config.generate.apiVersion;
+const minAPIversion = config.constants.minAPIversion;
+/**
+ * Generates the data for the visual
+ */
+function generateVisualOptions(visualName, apiVersion) {
+    const name = generateVisualName(visualName);
+    return {
+        name: name,
+        displayName: visualName,
+        guid: name + VisualGenerator.generateVisualGuid(),
+        visualClassName: 'Visual',
+        apiVersion: apiVersion
+    };
+}
+/**
+ *
+ */
+function generateVisualName(displayName) {
+    return displayName.replace(/(?:^\w|[A-Z]|\b\w|_|\s+)/g, (match, index) => {
+        if (/\s|_+/.test(match)) {
+            return "";
+        }
+        return index === 0 ? match.toLowerCase() : match.toUpperCase();
+    });
+}
+/**
+ * Creates a default pbiviz.json config file
+ *
+ * @param {string} visualPath - path to the visual
+ * @param {Object} options - visual information for populating the pbiviz.json template
+ * @param {string} templateName - external js files
+ */
+function createPbiVizJson(visualPath, options, templateName) {
+    // read the global template data
+    // and generate the actual file content
+    let data = template(options);
+    // write out the target file content
+    const targetPath = path.join(visualPath, 'pbiviz.json');
+    fs.writeFileSync(targetPath, data);
+    let templatePath = path.join(VISUAL_TEMPLATES_PATH, templateName);
+    templatePath = path.join(templatePath, 'pbiviz.json');
+    if (templateName && fileExists(templatePath)) {
+        //read the target file content 
+        data = fs.readJsonSync(targetPath);
+        //override externalJS settings with those of the local template file
+        const templateData = fs.readJsonSync(templatePath);
+        for (const objKey of Object.keys(templateData)) {
+            data[objKey] = templateData[objKey];
+        }
+        // write out the target file content
+        fs.writeJsonSync(targetPath, data);
+    }
+}
+/**
+ * Checks if the specified file exists
+ *
+ * @param {string} file - path to the file
+ */
+function fileExists(file) {
+    try {
+        fs.accessSync(file);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Copies the visual template directory
+ *
+ * @param {string} targetPath - file path to root of visual package
+ * @param {string} templateName - template to use for generating the visual
+ */
+function copyVisualTemplate(targetPath, templateName) {
+    fs.copySync(path.join(VISUAL_TEMPLATES_PATH, '_global'), targetPath);
+    fs.copySync(path.join(VISUAL_TEMPLATES_PATH, templateName), targetPath);
+}
+/**
+ * Checks if the specified template is valid
+ *
+ * @param {string} templateName - template to use for generating the visual
+ */
+function validTemplate(templateName) {
+    try {
+        fs.accessSync(path.join(VISUAL_TEMPLATES_PATH, templateName));
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+const defaultOptions = {
+    force: false,
+    template: 'default',
+    apiVersion: API_VERSION,
+    externalJS: []
+};
+export default class VisualGenerator {
+    /**
+     * Generates a new visual
+     *
+     * @param {string} targetPath - file path for creation of the new visual package
+     * @param {string} visualName - name of the new visual package
+     * @param {object} options - specify options for the visual generator
+     * @returns {Promise<string>} - promise resolves with the path to the newly created package
+     */
+    static generateVisual(targetPath, visualName, options) {
+        return new Promise((resolve, reject) => {
+            const buildOptions = lodashDefaults(options, defaultOptions);
+            if (!buildOptions.apiVersion || compareVersions(buildOptions.apiVersion, minAPIversion) === -1) {
+                return reject(new Error(`Can not generate a visual with an API below than ${minAPIversion}, current API is '${buildOptions.apiVersion}'.`));
+            }
+            const visualOptions = generateVisualOptions(visualName, buildOptions.apiVersion);
+            const validationResult = VisualGenerator.checkVisualName(visualOptions.name);
+            if (!visualOptions || !visualOptions.name || validationResult) {
+                return reject(new Error(validationResult || "Invalid visual name"));
+            }
+            if (!validTemplate(buildOptions.template)) {
+                return reject(new Error(`Invalid template "${buildOptions.template}"`));
+            }
+            const visualPath = path.join(targetPath, visualOptions.name);
+            fs.access(visualPath, err => {
+                if (!err && !buildOptions.force) {
+                    return reject(new Error('This visual already exists. Use force to overwrite.'));
+                }
+                try {
+                    if (!err && buildOptions.force) {
+                        fs.removeSync(visualPath);
+                    }
+                    copyVisualTemplate(visualPath, buildOptions.template);
+                    createPbiVizJson(visualPath, visualOptions, options.template);
+                    resolve(visualPath);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+    /**
+     * Generates a random GUID for your visual
+     */
+    static generateVisualGuid() {
+        return crypto.randomUUID().replace(/-/g, '').toUpperCase();
+    }
+    /**
+     * Check visual name
+     * Using https://github.com/mathiasbynens/mothereff.in/tree/master/js-properties
+     *
+     * @static
+     * @param {string} name Visual name
+     * @returns {string} error message
+     *
+     * @memberof VisualGenerator
+     */
+    static checkVisualName(name) {
+        const regexES3ReservedWord = /^(?:do|if|in|for|int|new|try|var|byte|case|char|else|enum|goto|long|null|this|true|void|with|break|catch|class|const|false|final|float|short|super|throw|while|delete|double|export|import|native|public|return|static|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
+        const regexNumber = /^(?![+-])([0-9\+\-\.]+)/;
+        const regexZeroWidth = /\u200c|\u200d/;
+        const regexpWrongSymbols = /^[a-zA-Z0-9]+$/;
+        const valueAsUnescapedString = name.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]{1,})\}/g, ($0, $1, $2) => {
+            const codePoint = parseInt($2 || $1, 16);
+            // If it’s a surrogate…
+            if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
+                // Return a character that is never valid in an identifier.
+                // This prevents the surrogate from pairing with another.
+                return '\0';
+            }
+            return String.fromCodePoint(codePoint);
+        });
+        if (regexNumber.test(name)) {
+            return `The visual name can't begin with a number digit`;
+        }
+        else if (!regexpWrongSymbols.test(name)) {
+            return `The visual name can contain only letters and numbers`;
+        }
+        else if (regexES3ReservedWord.test(valueAsUnescapedString)) {
+            return `The visual name cannot be equal to a reserved JavaScript keyword.
+                More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords`;
+        }
+        else if (regexZeroWidth.test(valueAsUnescapedString)) {
+            return `The visual name can't be empty`;
+        }
+    }
+}

package/lib/VisualManager.js

@@ -0,0 +1,316 @@
+/*
+ *  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 webpack from "webpack";
+import WebpackDevServer from "webpack-dev-server";
+import childProcess from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import ConsoleWriter from './ConsoleWriter.js';
+import VisualGenerator from './VisualGenerator.js';
+import { readJsonFromRoot, readJsonFromVisual } from './utils.js';
+import WebpackWrap from './WebPackWrap.js';
+import Package from './Package.js';
+import { Visual } from "./Visual.js";
+import { FeatureManager, Status } from "./FeatureManager.js";
+import { Severity, Stage } from "./features/FeatureTypes.js";
+import TemplateFetcher from "./TemplateFetcher.js";
+import { LintValidator } from "./LintValidator.js";
+const globalConfig = await readJsonFromRoot('config.json');
+const PBIVIZ_FILE = 'pbiviz.json';
+/**
+ * Represents an instance of a visual package based on file path
+ */
+export default class VisualManager {
+    basePath;
+    pbivizConfig;
+    capabilities;
+    webpackConfig;
+    visual;
+    package;
+    featureManager;
+    compiler;
+    webpackDevServer;
+    constructor(rootPath) {
+        this.basePath = rootPath;
+    }
+    async prepareVisual(pbivizFile = PBIVIZ_FILE) {
+        this.pbivizConfig = await readJsonFromVisual(pbivizFile, this.basePath);
+        if (this.pbivizConfig) {
+            await this.createVisualInstance();
+        }
+        else {
+            ConsoleWriter.error(pbivizFile + ' not found. You must be in the root of a visual project to run this command.');
+            process.exit(1);
+        }
+        return this;
+    }
+    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);
+            }
+        }
+    }
+    async createVisualInstance() {
+        this.capabilities = await readJsonFromVisual("capabilities.json", this.basePath);
+        this.visual = new Visual(this.capabilities, this.pbivizConfig);
+    }
+    async initializeWebpack(webpackOptions) {
+        const webpackWrap = new WebpackWrap();
+        this.webpackConfig = await webpackWrap.generateWebpackConfig(this, webpackOptions);
+        this.compiler = webpack(this.webpackConfig);
+        return this;
+    }
+    generatePackage(verbose = false) {
+        const callback = (err, stats) => {
+            this.parseCompilationResults(err, stats);
+            this.createPackageInstance();
+            const logs = this.validatePackage();
+            this.outputResults(logs, verbose);
+        };
+        this.compiler.run(callback);
+    }
+    /**
+     * Starts webpack server
+     */
+    startWebpackServer(generateDropFiles = false) {
+        ConsoleWriter.blank();
+        ConsoleWriter.info('Starting server...');
+        try {
+            if (generateDropFiles) {
+                this.prepareDropFiles();
+            }
+            this.webpackDevServer = new WebpackDevServer({
+                ...this.webpackConfig.devServer,
+                client: false,
+                hot: false,
+                devMiddleware: {
+                    writeToDisk: true
+                }
+            }, this.compiler);
+            (async () => {
+                await this.webpackDevServer.start();
+                ConsoleWriter.info(`Server listening on port ${this.webpackConfig.devServer.port}`);
+            })();
+            process.on('SIGINT', this.stopServer);
+            process.on('SIGTERM', this.stopServer);
+        }
+        catch (e) {
+            ConsoleWriter.error(e.message);
+            process.exit(1);
+        }
+    }
+    /**
+     * Validates the visual code
+     */
+    validateVisual(verbose = false) {
+        this.featureManager = new FeatureManager();
+        const { status, logs } = this.featureManager.validate(Stage.PreBuild, this.visual);
+        this.outputResults(logs, verbose);
+        if (status === Status.Error) {
+            process.exit(1);
+        }
+        return this;
+    }
+    /**
+     * Validates the visual package
+     */
+    validatePackage() {
+        const featureManager = new FeatureManager();
+        const { logs } = featureManager.validate(Stage.PostBuild, this.package);
+        return logs;
+    }
+    /**
+     * Outputs the results of the validation
+     */
+    outputResults({ errors, deprecation, warnings, info }, verbose) {
+        const headerMessage = {
+            error: `Visual doesn't support some features required for all custom visuals:`,
+            deprecation: `Some features are going to be required soon, please update the visual:`,
+            warning: `Visual doesn't support some features recommended for all custom visuals:`,
+            verboseInfo: `Visual can be improved by adding some features:`,
+            shortInfo: `Visual can be improved by adding ${info.length} more optional features.`
+        };
+        this.outputLogsWithHeadMessage(headerMessage.error, errors, Severity.Error);
+        this.outputLogsWithHeadMessage(headerMessage.deprecation, deprecation, Severity.Deprecation);
+        this.outputLogsWithHeadMessage(headerMessage.warning, warnings, Severity.Warning);
+        const verboseSuggestion = 'Run `pbiviz package` with --verbose flag to see more details.';
+        const headerInfoMessage = headerMessage[verbose ? "verboseInfo" : "shortInfo"];
+        const infoLogs = (!info.length || verbose) ? info : [verboseSuggestion];
+        this.outputLogsWithHeadMessage(headerInfoMessage, infoLogs, Severity.Info);
+    }
+    /**
+     * Displays visual info
+     */
+    displayInfo() {
+        if (this.pbivizConfig) {
+            ConsoleWriter.infoTable(this.pbivizConfig);
+        }
+        else {
+            ConsoleWriter.error('Unable to load visual info. Please ensure the package is valid.');
+        }
+    }
+    /**
+     * Creates a new visual
+     */
+    static async createVisual(rootPath, visualName, generateOptions) {
+        ConsoleWriter.info('Creating new visual');
+        if (generateOptions.force) {
+            ConsoleWriter.warning('Running with force flag. Existing files will be overwritten');
+        }
+        try {
+            const config = await readJsonFromRoot('config.json');
+            if (config.visualTemplates[generateOptions.template]) {
+                new TemplateFetcher(generateOptions.template, visualName, undefined)
+                    .fetch();
+                return;
+            }
+            const newVisualPath = await VisualGenerator.generateVisual(rootPath, visualName, generateOptions);
+            await VisualManager.installPackages(newVisualPath).then(() => ConsoleWriter.done('Visual creation complete'));
+            return new VisualManager(newVisualPath);
+        }
+        catch (error) {
+            ConsoleWriter.error(['Unable to create visual.\n', error]);
+            process.exit(1);
+        }
+    }
+    /**
+     * Install npm dependencies for visual
+     */
+    static installPackages(visualPath) {
+        return new Promise(function (resolve, reject) {
+            ConsoleWriter.info('Installing packages...');
+            childProcess.exec(`npm install`, { cwd: visualPath }, (err) => {
+                if (err) {
+                    reject(new Error('Package install failed.'));
+                }
+                else {
+                    ConsoleWriter.info('Installed packages.');
+                    resolve();
+                }
+            });
+        });
+    }
+    doesPBIVIZExists(pbivizFile) {
+        return fs.existsSync(pbivizFile);
+    }
+    prepareDropFiles() {
+        this.webpackConfig.devServer.setupMiddlewares = (middlewares, devServer) => {
+            const { headers, publicPath, static: { directory } } = this.webpackConfig.devServer;
+            const assets = ['visual.js', 'visual.css', 'pbiviz.json'];
+            const setHeaders = (res) => {
+                Object.getOwnPropertyNames(headers)
+                    .forEach(property => res.header(property, headers[property]));
+            };
+            const readFile = (file, res, name) => {
+                const assetMiddleware = (req, middlewareRes, next) => {
+                    fs.readFile(file)
+                        .then(content => {
+                        middlewareRes.write(content);
+                        ConsoleWriter.info(`Serving ${name}`);
+                        middlewareRes.end();
+                    })
+                        .catch(err => {
+                        ConsoleWriter.error(`Error serving ${name}: ${err.message}`);
+                        next();
+                    });
+                };
+                middlewares.unshift({
+                    name,
+                    path: `${publicPath}/${name}`,
+                    middleware: assetMiddleware
+                });
+                res.end();
+            };
+            assets.forEach(asset => {
+                devServer.app.get(`${publicPath}/${asset}`, function (req, res) {
+                    setHeaders(res);
+                    readFile(path.join(directory, asset), res, asset);
+                });
+            });
+            return middlewares;
+        };
+    }
+    async stopServer() {
+        ConsoleWriter.blank();
+        ConsoleWriter.info("Stopping server...");
+        if (this.webpackDevServer) {
+            await this.webpackDevServer.stop();
+            this.webpackDevServer = null;
+        }
+    }
+    createPackageInstance() {
+        const pathToJSContent = path.join((this.pbivizConfig.build ?? globalConfig.build).dropFolder, "visual.js");
+        const sourceCode = fs.readFileSync(pathToJSContent, "utf8");
+        this.package = new Package(sourceCode, this.capabilities, this.visual.visualFeatureType);
+    }
+    parseCompilationResults(err, stats) {
+        ConsoleWriter.blank();
+        if (err) {
+            ConsoleWriter.error(`Package wasn't created. ${JSON.stringify(err)}`);
+        }
+        if (stats?.compilation.errors.length) {
+            stats.compilation.errors.forEach(error => ConsoleWriter.error(error.message));
+            ConsoleWriter.error(`Package wasn't created. ${stats.compilation.errors.length} errors found.`);
+        }
+        if (!err && !stats?.compilation.errors.length) {
+            ConsoleWriter.done('Build completed successfully');
+        }
+        else {
+            process.exit(1);
+        }
+    }
+    outputLogsWithHeadMessage(headMessage, logs, severity) {
+        if (!logs.length) {
+            return;
+        }
+        let outputLog;
+        switch (severity) {
+            case Severity.Deprecation:
+            case Severity.Error:
+                outputLog = ConsoleWriter.error;
+                break;
+            case Severity.Warning:
+                outputLog = ConsoleWriter.warning;
+                break;
+            default:
+                outputLog = ConsoleWriter.info;
+                break;
+        }
+        if (headMessage) {
+            outputLog(headMessage);
+            ConsoleWriter.blank();
+        }
+        logs.forEach(error => outputLog(error));
+        ConsoleWriter.blank();
+    }
+}