powerbi-visuals-tools 4.3.3 → 5.0.1

package/lib/VisualManager.js

@@ -0,0 +1,193 @@
+/*
+ *  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 TemplateFetcher from "./TemplateFetcher.js";
+const PBIVIZ_FILE = 'pbiviz.json';
+/**
+ * Represents an instance of a visual package based on file path
+ */
+export default class VisualManager {
+    basePath;
+    pbivizConfig;
+    webpackConfig;
+    compiler;
+    webpackDevServer;
+    constructor(rootPath) {
+        this.basePath = rootPath;
+    }
+    prepareVisual() {
+        if (this.doesPBIVIZExists()) {
+            this.pbivizConfig = readJsonFromVisual(PBIVIZ_FILE, this.basePath);
+        }
+        else {
+            throw new Error(PBIVIZ_FILE + ' not found. You must be in the root of a visual project to run this command.');
+        }
+        return this;
+    }
+    async initializeWebpack(webpackOptions) {
+        const webpackWrap = new WebpackWrap();
+        this.webpackConfig = await webpackWrap.generateWebpackConfig(this, webpackOptions);
+        this.compiler = webpack(this.webpackConfig);
+        return this;
+    }
+    generatePackage() {
+        const callback = (err, stats) => {
+            this.parseCompilationResults(err, stats);
+        };
+        this.compiler.run(callback);
+    }
+    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);
+        }
+    }
+    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 package
+     */
+    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 = 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() {
+        return fs.existsSync(PBIVIZ_FILE);
+    }
+    prepareDropFiles() {
+        this.webpackConfig.devServer.onBeforeSetupMiddleware = (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) => {
+                fs.readFile(file).then(function (content) {
+                    res.write(content);
+                    res.end();
+                });
+            };
+            assets.forEach(asset => {
+                devServer.app.get(`${publicPath}/${asset}`, function (req, res) {
+                    setHeaders(res);
+                    readFile(path.join(directory, asset), res);
+                });
+            });
+        };
+    }
+    stopServer() {
+        ConsoleWriter.blank();
+        ConsoleWriter.info("Stopping server...");
+        if (this.webpackDevServer) {
+            this.webpackDevServer.close();
+            this.webpackDevServer = null;
+        }
+    }
+    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');
+        }
+    }
+}

package/lib/WebPackWrap.js

@@ -1,60 +1,57 @@
 "use strict";
-
-const fs = require('fs-extra');
-const os = require('os');
-const path = require('path');
-const webpack = require('webpack');
-const config = require('../config.json');
-const { PowerBICustomVisualsWebpackPlugin } = require('powerbi-visuals-webpack-plugin');
-const encoding = "utf8";
-const ConsoleWriter = require('../lib/ConsoleWriter');
-const ExtraWatchWebpackPlugin = require('extra-watch-webpack-plugin');
-const Visualizer = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
-const util = require('util');
-const exec = util.promisify(require('child_process').exec);
-const CertificateTools = require("../lib/CertificateTools");
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import webpack from 'webpack';
+import util from 'util';
+const exec = util.promisify(processExec);
+import { exec as processExec } from 'child_process';
+import lodashCloneDeep from 'lodash.clonedeep';
+import ExtraWatchWebpackPlugin from 'extra-watch-webpack-plugin';
+import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
+import { PowerBICustomVisualsWebpackPlugin } from 'powerbi-visuals-webpack-plugin';
+import ConsoleWriter from './ConsoleWriter.js';
+import { resolveCertificate } from "./CertificateTools.js";
+import { getRootPath, readJsonFromRoot, readJsonFromVisual } from './utils.js';
+const config = readJsonFromRoot('config.json');
+const npmPackage = readJsonFromRoot('package.json');
 const visualPlugin = "visualPlugin.ts";
-const lodashCloneDeep = require('lodash.clonedeep');
-const npmPackage = require('../package.json');
-
-class WebPackGenerator {
-
+const encoding = "utf8";
+export default class WebPackWrap {
+    pbiviz;
+    webpackConfig;
     static async prepareFoldersAndFiles(visualPackage) {
-        let tmpFolder = path.join(visualPackage.basePath, ".tmp");
-        let precompileFolder = path.join(visualPackage.basePath, config.build.precompileFolder);
-        let dropFolder = path.join(visualPackage.basePath, config.build.dropFolder);
-        let packgeDropFolder = path.join(visualPackage.basePath, config.package.dropFolder);
-        let visualPluginFile = path.join(visualPackage.basePath, config.build.precompileFolder, visualPlugin);
+        const tmpFolder = path.join(visualPackage.basePath, ".tmp");
+        const precompileFolder = path.join(visualPackage.basePath, config.build.precompileFolder);
+        const dropFolder = path.join(visualPackage.basePath, config.build.dropFolder);
+        const packageDropFolder = path.join(visualPackage.basePath, config.package.dropFolder);
+        const visualPluginFile = path.join(visualPackage.basePath, config.build.precompileFolder, visualPlugin);
         await fs.ensureDir(tmpFolder);
         await fs.ensureDir(precompileFolder);
         await fs.ensureDir(dropFolder);
-        await fs.ensureDir(packgeDropFolder);
+        await fs.ensureDir(packageDropFolder);
         await fs.createFile(visualPluginFile);
     }
-
     static loadAPIPackage() {
         try {
-            let basePath = require.resolve("powerbi-visuals-api", {
-                paths: [process.cwd()]
-            });
-            return require(basePath);
-        } catch (ex) {
+            return import("file://" + path.join(process.cwd(), "node_modules", "powerbi-visuals-api", "index.js"));
+        }
+        catch (ex) {
             return null;
         }
     }
-
     async installAPIpackage() {
-        let apiVersion = this.pbiviz.apiVersion ? `~${this.pbiviz.apiVersion}` : "latest";
+        const apiVersion = this.pbiviz.apiVersion ? `~${this.pbiviz.apiVersion}` : "latest";
         try {
             ConsoleWriter.info(`Installing API: ${apiVersion}...`);
-            let {
-                stdout,
-                stderr
-            } = await exec(`npm install --save powerbi-visuals-api@${apiVersion}`);
-            ConsoleWriter.info(stdout);
-            ConsoleWriter.warn(stderr);
+            const { stdout, stderr } = await exec(`npm install --save powerbi-visuals-api@${apiVersion}`);
+            if (stdout)
+                ConsoleWriter.info(stdout);
+            if (stderr)
+                ConsoleWriter.warning(stderr);
             return true;
-        } catch (ex) {
+        }
+        catch (ex) {
             if (ex.message.indexOf("No matching version found for powerbi-visuals-api") !== -1) {
                 throw new Error(`Error: Invalid API version: ${apiVersion}`);
             }
@@ -62,7 +59,6 @@ class WebPackGenerator {
             return false;
         }
     }
-
     enableOptimization() {
         this.webpackConfig.mode = "production";
         this.webpackConfig.optimization = {
@@ -70,14 +66,12 @@ class WebPackGenerator {
             minimize: true
         };
     }
-
     async configureDevServer(visualPackage, port = 8080) {
-        let options = await CertificateTools.resolveCertificate();
-
+        const options = await resolveCertificate();
         this.webpackConfig.devServer = {
             ...this.webpackConfig.devServer,
             hot: false,
-            port: port || config.server.port,
+            port,
             static: {
                 directory: path.join(visualPackage.basePath, config.build.dropFolder),
                 publicPath: config.server.assetsRoute
@@ -93,65 +87,60 @@ class WebPackGenerator {
             }
         };
     }
-
     configureVisualPlugin(options, tsconfig, visualPackage) {
-        const visualJSFilePath = visualPackage.buildPath(tsconfig.compilerOptions.out || tsconfig.compilerOptions.outDir);
+        const visualJSFilePath = tsconfig.compilerOptions.out || tsconfig.compilerOptions.outDir;
         this.webpackConfig.output.path = path.join(visualPackage.basePath, config.build.dropFolder);
         this.webpackConfig.output.filename = "[name]";
-        let visualPluginPath = path.join(process.cwd(), config.build.precompileFolder, visualPlugin);
-        this.webpackConfig.plugins.push(
-            new webpack.WatchIgnorePlugin({ paths: [visualPluginPath] })
-        );
+        const visualPluginPath = path.join(process.cwd(), config.build.precompileFolder, visualPlugin);
+        this.webpackConfig.watchOptions.ignored.push(visualPluginPath);
         if (tsconfig.compilerOptions.out) {
             this.webpackConfig.entry = {
                 "visual.js": visualJSFilePath
             };
-        } else {
+        }
+        else {
             this.webpackConfig.entry["visual.js"] = [visualPluginPath];
             this.webpackConfig.output.library = `${this.pbiviz.visual.guid}${options.devMode ? "_DEBUG" : ""}`;
             this.webpackConfig.output.libraryTarget = 'var';
         }
     }
-
     async getEnvironmentDetails() {
-        let env = {};
-        env.nodeVersion = process.versions.node;
-        env.osPlatform = await os.platform();
-        env.osVersion = await os.version ? os.version() : "undefined";
-        env.osReleaseVersion = await os.release();
-        env.toolsVersion = npmPackage.version;
+        const env = {
+            nodeVersion: process.versions.node,
+            osPlatform: await os.platform(),
+            osVersion: await os.version ?? "undefined",
+            osReleaseVersion: await os.release(),
+            toolsVersion: npmPackage.version
+        };
         return env;
     }
-
     async configureCustomVisualsWebpackPlugin(visualPackage, options, tsconfig) {
-        let pluginConfiguration = lodashCloneDeep(visualPackage.config);
+        const pluginConfiguration = lodashCloneDeep(visualPackage.pbivizConfig);
         //(?=\D*$) - positive look-ahead to find last version symbols and exclude any non-digit symbols after the version.
-        let regexFullVersion = /(?:\d+\.?){1,3}(?=\D*$)/;
-        let regexMinorVersion = /\d+(?:\.\d+)?/;
+        const regexFullVersion = /(?:\d+\.?){1,3}(?=\D*$)/;
+        const regexMinorVersion = /\d+(?:\.\d+)?/;
         let apiVersionInstalled;
         try {
-            apiVersionInstalled = (await exec('npm list powerbi-visuals-api version')).stdout.match(regexFullVersion)[0];
-        } catch (err) {
-            ConsoleWriter.warn(`"powerbi-visuals-api" is not installed`);
+            const subprocess = await exec('npm list powerbi-visuals-api version');
+            apiVersionInstalled = subprocess.stdout.match(regexFullVersion)[0];
+        }
+        catch (err) {
+            ConsoleWriter.warning(`"powerbi-visuals-api" is not installed`);
         }
         // if the powerbi-visual-api package wasn't installed
         // install the powerbi-visual-api, with version from apiVersion in pbiviz.json
         // or the latest API, if apiVersion is absent in pbiviz.json
-        if (!apiVersionInstalled || (typeof this.pbiviz.apiVersion !== "undefined" && this.pbiviz.apiVersion.match(regexMinorVersion)[0] != apiVersionInstalled.match(regexMinorVersion)[0])) {
-            ConsoleWriter.warn(`installed "powerbi-visuals-api" version - "${apiVersionInstalled}", is not match with the version specified in pbviz.json - "${this.pbiviz.apiVersion}".`);
+        if (!apiVersionInstalled || !this.pbiviz.apiVersion || this.pbiviz.apiVersion.match(regexMinorVersion)[0] != apiVersionInstalled.match(regexMinorVersion)[0]) {
+            ConsoleWriter.warning(`installed "powerbi-visuals-api" version - "${apiVersionInstalled}", is not match with the version specified in pbviz.json - "${this.pbiviz.apiVersion}".`);
             await this.installAPIpackage();
         }
-
         // pluginConfiguration.env = await this.getEnvironmentDetails();
-
-        let api = WebPackGenerator.loadAPIPackage(visualPackage);
+        const api = await WebPackWrap.loadAPIPackage();
         pluginConfiguration.apiVersion = api.version;
         pluginConfiguration.capabilitiesSchema = api.schemas.capabilities;
         pluginConfiguration.pbivizSchema = api.schemas.pbiviz;
         pluginConfiguration.stringResourcesSchema = api.schemas.stringResources;
         pluginConfiguration.dependenciesSchema = api.schemas.dependencies;
-
-
         pluginConfiguration.customVisualID = `CustomVisual_${this.pbiviz.visual.guid}`.replace(/[^\w\s]/gi, '');
         pluginConfiguration.devMode = (typeof options.devMode === "undefined") ? true : options.devMode;
         pluginConfiguration.generatePbiviz = options.generatePbiviz;
@@ -165,49 +154,30 @@ class WebPackGenerator {
         pluginConfiguration.compression = options.compression;
         return pluginConfiguration;
     }
-
     async appendPlugins(options, visualPackage, tsconfig) {
-        let pluginConfiguration = await this.configureCustomVisualsWebpackPlugin(visualPackage, options, tsconfig);
-
+        const pluginConfiguration = await this.configureCustomVisualsWebpackPlugin(visualPackage, options, tsconfig);
         let statsFilename = config.build.stats.split("/").pop();
-        let statsLocation = config.build.stats.split("/").slice(0, -1).join(path.sep);
-        statsFilename = statsFilename.split(".").slice(0, -1).join(".");
+        const statsLocation = config.build.stats.split("/").slice(0, -1).join(path.sep);
+        statsFilename = statsFilename?.split(".").slice(0, -1).join(".");
         statsFilename = `${statsFilename}.${options.devMode ? "dev" : "prod"}.html`;
-
-        if (!options.disableStats) {
-            this.webpackConfig.plugins.push(
-                new Visualizer({
-                    reportFilename: path.join(statsLocation, statsFilename),
-                    openAnalyzer: false,
-                    analyzerMode: `static`
-                })
-            );
+        if (options.stats) {
+            this.webpackConfig.plugins.push(new BundleAnalyzerPlugin({
+                reportFilename: path.join(statsLocation, statsFilename),
+                openAnalyzer: false,
+                analyzerMode: `static`
+            }));
         }
-        this.webpackConfig.plugins.push(
-            new PowerBICustomVisualsWebpackPlugin(pluginConfiguration),
-            new ExtraWatchWebpackPlugin({
-                files: [visualPackage.buildPath(this.pbiviz.capabilities)]
-            }),
-            new webpack.ProvidePlugin({
-                window: 'realWindow',
-                define: 'fakeDefine',
-                powerbi: 'globalPowerbi'
-            })
-        );
-
+        this.webpackConfig.plugins.push(new PowerBICustomVisualsWebpackPlugin(pluginConfiguration), new ExtraWatchWebpackPlugin({
+            files: this.pbiviz.capabilities
+        }));
         if (options.devtool === "source-map" && this.webpackConfig.devServer.port) {
-            this.webpackConfig.plugins.push(
-                new webpack.SourceMapDevToolPlugin({
-                    filename: '[file].map',
-                    publicPath: `https://localhost:${this.webpackConfig.devServer.port}/assets/`
-                })
-            );
+            this.webpackConfig.plugins.push(new webpack.SourceMapDevToolPlugin({
+                filename: '[file].map',
+                publicPath: `https://localhost:${this.webpackConfig.devServer.port}/assets/`
+            }));
         }
     }
-
-    useLoader({
-        fast = false
-    }) {
+    async useLoader({ fast = false }) {
         let tsOptions = {};
         if (fast) {
             tsOptions = {
@@ -219,46 +189,37 @@ class WebPackGenerator {
             test: /(\.ts)x?$/,
             use: [
                 {
-                    loader: require.resolve('ts-loader'),
+                    loader: path.resolve(getRootPath(), "node_modules", "ts-loader"),
                     options: tsOptions
                 }
             ]
         });
     }
-
     async prepareWebPackConfig(visualPackage, options, tsconfig) {
-        this.webpackConfig = require('./webpack.config');
+        this.webpackConfig = Object.assign({}, await import('./webpack.config.js')).default;
         if (options.minifyJS) {
             this.enableOptimization();
         }
-
         if (options.devtool) {
             this.webpackConfig.devtool = options.devtool;
         }
-
         await this.appendPlugins(options, visualPackage, tsconfig);
         await this.configureDevServer(visualPackage, options.devServerPort);
         await this.configureVisualPlugin(options, tsconfig, visualPackage);
-        this.useLoader({
+        await this.useLoader({
             fast: options.fast
         });
-
         return this.webpackConfig;
     }
-
     async assemblyExternalJSFiles(visualPackage) {
-        let externalJSFilesContent = "";
-        let externalJSFilesPath = path.join(visualPackage.basePath, config.build.precompileFolder, "externalJS.js");
-        await fs.writeFile(
-            externalJSFilesPath,
-            externalJSFilesContent, {
+        const externalJSFilesContent = "";
+        const externalJSFilesPath = path.join(visualPackage.basePath, config.build.precompileFolder, "externalJS.js");
+        await fs.writeFile(externalJSFilesPath, externalJSFilesContent, {
             encoding: encoding
         });
-
         return externalJSFilesPath;
     }
-
-    async applyWebpackConfig(visualPackage, options = {
+    async generateWebpackConfig(visualPackage, options = {
         devMode: false,
         generateResources: false,
         generatePbiviz: false,
@@ -267,27 +228,17 @@ class WebPackGenerator {
         devServerPort: 8080,
         fast: false,
         compression: 0,
-        disableStats: false
+        stats: true
     }) {
-        const tsconfigPath = visualPackage.buildPath('tsconfig.json');
-        const tsconfig = require(tsconfigPath);
-
-        this.pbivizJsonPath = visualPackage.buildPath('pbiviz.json');
-        this.pbiviz = require(this.pbivizJsonPath);
-
-        const capabliliesPath = this.pbiviz.capabilities;
-        visualPackage.config.capabilities = capabliliesPath;
-
+        const tsconfig = readJsonFromVisual('tsconfig.json');
+        this.pbiviz = readJsonFromVisual('pbiviz.json');
+        const capabilitiesPath = this.pbiviz.capabilities;
+        visualPackage.pbivizConfig.capabilities = capabilitiesPath;
         const dependenciesPath = this.pbiviz.dependencies && path.join(process.cwd(), this.pbiviz.dependencies);
-        const dependenciesFile = fs.existsSync(dependenciesPath) && require(dependenciesPath);
-        visualPackage.config.dependencies = typeof dependenciesFile === 'object' ? dependenciesFile : {};
-
-        await WebPackGenerator.prepareFoldersAndFiles(visualPackage);
-
-        let webpackConfig = await this.prepareWebPackConfig(visualPackage, options, tsconfig);
-
-        return { webpackConfig };
+        const dependenciesFile = fs.existsSync(dependenciesPath) && JSON.parse(fs.readFileSync(dependenciesPath));
+        visualPackage.pbivizConfig.dependencies = typeof dependenciesFile === 'object' ? dependenciesFile : {};
+        await WebPackWrap.prepareFoldersAndFiles(visualPackage);
+        const webpackConfig = await this.prepareWebPackConfig(visualPackage, options, tsconfig);
+        return webpackConfig;
     }
 }
-
-module.exports = WebPackGenerator;

package/lib/utils.js

@@ -1,8 +1,8 @@
-const fs = require('fs-extra');
-let https = require("https");
-let path = require("path");
-
-function download(url, pathToFile) {
+import fs from 'fs-extra';
+import https from "https";
+import path from "path";
+import { fileURLToPath } from 'node:url';
+export function download(url, pathToFile) {
     return new Promise((resolve, reject) => {
         const fileStream = fs.createWriteStream(pathToFile);
         https.get(url, (res) => {
@@ -13,14 +13,21 @@ function download(url, pathToFile) {
             .on('error', (error) => reject(error));
     });
 }
-
-function createFolder(folderName) {
-    let folder = path.join("./", folderName);
+export function createFolder(folderName) {
+    const folder = path.join("./", folderName);
     fs.ensureDirSync(folder);
     return folder;
 }
-
-module.exports = { 
-    download,
-    createFolder
- };
+export function getRootPath() {
+    const pathToDirectory = fileURLToPath(import.meta.url);
+    return path.join(pathToDirectory, "..", "..");
+}
+export function readFileFromRoot(filePath) {
+    return fs.readFileSync(path.join(getRootPath(), filePath), "utf8");
+}
+export function readJsonFromRoot(filePath) {
+    return JSON.parse(readFileFromRoot(filePath));
+}
+export function readJsonFromVisual(filePath, visualPath) {
+    return JSON.parse(fs.readFileSync(path.join(visualPath ?? process.cwd(), filePath), "utf8"));
+}