powerbi-visuals-tools 7.0.0 → 7.0.1

package/lib/WebPackWrap.js

@@ -0,0 +1,274 @@
+"use strict";
+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, LocalizationLoader } from 'powerbi-visuals-webpack-plugin';
+import ConsoleWriter from './ConsoleWriter.js';
+import { resolveCertificate } from "./CertificateTools.js";
+import { readJsonFromRoot, readJsonFromVisual } from './utils.js';
+const config = await readJsonFromRoot('config.json');
+const npmPackage = await readJsonFromRoot('package.json');
+const visualPlugin = "visualPlugin.ts";
+const encoding = "utf8";
+export default class WebPackWrap {
+    pbiviz;
+    webpackConfig;
+    static async prepareFoldersAndFiles(visualPackage) {
+        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(packageDropFolder);
+        await fs.createFile(visualPluginFile);
+    }
+    static loadAPIPackage() {
+        const apiPath = path.join(process.cwd(), "node_modules", "powerbi-visuals-api");
+        const doesAPIExist = fs.pathExistsSync(apiPath);
+        if (!doesAPIExist) {
+            ConsoleWriter.error(`Can't find powerbi-visuals-api package`);
+            process.exit(1);
+        }
+        return import("file://" + path.join(apiPath, "index.js"));
+    }
+    async installAPIpackage() {
+        const apiVersion = this.pbiviz.apiVersion ? `~${this.pbiviz.apiVersion}` : "latest";
+        try {
+            ConsoleWriter.info(`Installing API: ${apiVersion}...`);
+            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) {
+            if (ex.message.indexOf("No matching version found for powerbi-visuals-api") !== -1) {
+                throw new Error(`Error: Invalid API version: ${apiVersion}`);
+            }
+            ConsoleWriter.error(`npm install powerbi-visuals-api@${apiVersion} failed`);
+            return false;
+        }
+    }
+    enableOptimization() {
+        this.webpackConfig.mode = "production";
+        this.webpackConfig.optimization = {
+            concatenateModules: false,
+            minimize: true
+        };
+    }
+    async configureDevServer(visualPackage, port = 8080) {
+        const options = await resolveCertificate();
+        this.webpackConfig.devServer = {
+            ...this.webpackConfig.devServer,
+            hot: false,
+            port,
+            static: {
+                directory: path.join(visualPackage.basePath, config.build.dropFolder),
+                publicPath: config.server.assetsRoute
+            },
+            server: {
+                type: 'https',
+                options: {
+                    key: options.key,
+                    cert: options.cert,
+                    pfx: options.pfx,
+                    passphrase: options.passphrase
+                }
+            }
+        };
+    }
+    configureVisualPlugin(options, tsconfig, visualPackage) {
+        const visualJSFilePath = tsconfig.compilerOptions.out || tsconfig.compilerOptions.outDir;
+        this.webpackConfig.output.path = path.join(visualPackage.basePath, config.build.dropFolder);
+        this.webpackConfig.output.filename = "[name]";
+        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 {
+            this.webpackConfig.entry["visual.js"] = [visualPluginPath];
+            this.webpackConfig.output.library = `${this.pbiviz.visual.guid}${options.devMode ? "_DEBUG" : ""}`;
+            this.webpackConfig.output.libraryTarget = 'var';
+        }
+    }
+    async getEnvironmentDetails() {
+        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) {
+        if (options.skipApiCheck) {
+            ConsoleWriter.warning(`Skipping API check. Tools started with --skipApi flag.`);
+        }
+        else {
+            await this.configureAPIVersion();
+        }
+        const api = await WebPackWrap.loadAPIPackage();
+        const dependenciesPath = typeof this.pbiviz.dependencies === "string" && path.join(process.cwd(), this.pbiviz.dependencies);
+        let pluginConfiguration = {
+            ...lodashCloneDeep(visualPackage.pbivizConfig),
+            apiVersion: api.version,
+            capabilitiesSchema: api.schemas.capabilities,
+            pbivizSchema: api.schemas.pbiviz,
+            stringResourcesSchema: api.schemas.stringResources,
+            dependenciesSchema: api.schemas.dependencies,
+            customVisualID: `CustomVisual_${this.pbiviz.visual.guid}`.replace(/[^\w\s]/gi, ''),
+            devMode: options.devMode,
+            generatePbiviz: options.generatePbiviz,
+            generateResources: options.generateResources,
+            minifyJS: options.minifyJS,
+            dependencies: fs.existsSync(dependenciesPath) ? this.pbiviz.dependencies : null,
+            modules: typeof tsconfig.compilerOptions.outDir !== "undefined",
+            visualSourceLocation: path.posix.relative(config.build.precompileFolder, tsconfig.files[0]).replace(/(\.ts)x|\.ts/, ""),
+            pluginLocation: path.join(config.build.precompileFolder, "visualPlugin.ts"),
+            compression: options.compression,
+            certificationAudit: options.certificationAudit,
+            certificationFix: options.certificationFix,
+        };
+        return pluginConfiguration;
+    }
+    async configureAPIVersion() {
+        //(?<=powerbi-visuals-api@) - positive look-behind to find version installed in visual and get 3 level version.
+        const regexFullVersion = /(?<=powerbi-visuals-api@)((?:\d+\.?){1,3})/g;
+        //get only first 2 parts of version
+        const regexMajorVersion = /\d+(?:\.\d+)?/;
+        let listResults;
+        try {
+            listResults = (await exec('npm list powerbi-visuals-api version')).stdout;
+        }
+        catch (error) {
+            listResults = error.stdout;
+        }
+        const installedAPIVersion = listResults.match(regexFullVersion)?.[0] ?? "not found";
+        const doesAPIExist = fs.pathExistsSync(path.join(process.cwd(), "node_modules", "powerbi-visuals-api"));
+        // 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
+        const isAPIConfigured = doesAPIExist && installedAPIVersion && this.pbiviz.apiVersion;
+        if (!isAPIConfigured || this.pbiviz.apiVersion.match(regexMajorVersion)[0] != installedAPIVersion.match(regexMajorVersion)[0]) {
+            ConsoleWriter.warning(`installed "powerbi-visuals-api" version - "${installedAPIVersion}", is not match with the version specified in pbviz.json - "${this.pbiviz.apiVersion}".`);
+            await this.installAPIpackage();
+        }
+    }
+    async appendPlugins(options, visualPackage, tsconfig) {
+        const pluginConfiguration = await this.configureCustomVisualsWebpackPlugin(visualPackage, options, tsconfig);
+        let statsFilename = config.build.stats.split("/").pop();
+        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.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: this.pbiviz.capabilities
+        }));
+        // Only add separate source map files when NOT using inline source maps
+        if (options.devMode && options.devtool && this.webpackConfig.devServer.port &&
+            options.devtool !== "inline-source-map") {
+            this.webpackConfig.plugins.push(new webpack.SourceMapDevToolPlugin({
+                filename: '[file].map',
+                publicPath: `https://localhost:${this.webpackConfig.devServer.port}/assets/`
+            }));
+        }
+    }
+    async configureLoaders({ fast = false, includeAllLocales = false }) {
+        this.webpackConfig.module.rules.push({
+            test: /(\.ts)x?$/,
+            use: [
+                {
+                    loader: "ts-loader",
+                    options: fast
+                        ? {
+                            transpileOnly: false,
+                            experimentalWatchApi: false
+                        }
+                        : {}
+                }
+            ]
+        });
+        if (!includeAllLocales) {
+            this.webpackConfig.module.rules.push({
+                test: /powerbiGlobalizeLocales\.js$/, // path to file with all locales declared in formattingutils
+                loader: LocalizationLoader
+            });
+        }
+    }
+    async prepareWebPackConfig(visualPackage, options, tsconfig) {
+        this.webpackConfig = Object.assign({}, await import('./webpack.config.js')).default;
+        // Set webpack mode based on devMode
+        if (options.devMode) {
+            this.webpackConfig.mode = "development";
+        }
+        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);
+        await this.configureLoaders({
+            fast: options.fast,
+            includeAllLocales: options.allLocales
+        });
+        return this.webpackConfig;
+    }
+    async assemblyExternalJSFiles(visualPackage) {
+        const externalJSFilesContent = "";
+        const externalJSFilesPath = path.join(visualPackage.basePath, config.build.precompileFolder, "externalJS.js");
+        await fs.writeFile(externalJSFilesPath, externalJSFilesContent, {
+            encoding: encoding
+        });
+        return externalJSFilesPath;
+    }
+    async generateWebpackConfig(visualPackage, options = {
+        devMode: false,
+        generateResources: false,
+        generatePbiviz: false,
+        minifyJS: true,
+        minify: true,
+        devServerPort: 8080,
+        fast: false,
+        compression: 0,
+        stats: true,
+        skipApiCheck: false,
+        allLocales: false,
+        pbivizFile: 'pbiviz.json',
+        certificationAudit: false,
+        certificationFix: false,
+    }) {
+        const tsconfig = await readJsonFromVisual('tsconfig.json');
+        this.pbiviz = await readJsonFromVisual(options.pbivizFile);
+        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) && 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;
+    }
+}

package/lib/features/APIVersion.js

@@ -0,0 +1,16 @@
+import { readJsonFromRoot } from "../utils.js";
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class APIVersion {
+    static featureName = "Api";
+    static severity = Severity.Error;
+    static stage = Stage.PreBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer;
+    static minAPIversion;
+    static errorMessage;
+    static async isSupported(visual) {
+        const globalConfig = await readJsonFromRoot('config.json');
+        this.minAPIversion = globalConfig.constants.minAPIversion;
+        this.errorMessage = `API version must be at least ${this.minAPIversion}.`;
+        return visual.doesAPIVersionMatch(this.minAPIversion);
+    }
+}

package/lib/features/AdvancedEditMode.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class AdvancedEditMode {
+    static featureName = "Advanced Edit Mode";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/advanced-edit-mode";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return !packageInstance.isCapabilityEnabled({ advancedEditMode: 0 }); // 0 - Advanced edit mode is disabled
+    }
+}

package/lib/features/AllowInteractions.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class AllowInteractions {
+    static featureName = "Allow Interactions";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/visuals-interactions";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain('.allowInteractions');
+    }
+}

package/lib/features/AnalyticsPane.js

@@ -0,0 +1,17 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class AnalyticsPane {
+    static featureName = "Analytics Pane";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/analytics-pane";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return (packageInstance.isCapabilityEnabled({
+            objects: {
+                objectCategory: 2
+            }
+        }) ||
+            packageInstance.contain("analyticsPane=true"));
+    }
+}

package/lib/features/BaseFeature.js

@@ -0,0 +1,9 @@
+export default class BaseFeature {
+    static severity;
+    static stage;
+    static visualFeatureType;
+    static featureName;
+    static documentationLink;
+    static errorMessage;
+    static isSupported() { }
+}

package/lib/features/Bookmarks.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class Bookmarks {
+    static featureName = "Bookmarks";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/bookmarks-support";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain("applySelectionFromFilter") || packageInstance.contain("registerOnSelectCallback");
+    }
+}

package/lib/features/ColorPalette.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class ColorPalette {
+    static featureName = "Color Palette";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/add-colors-power-bi-visual";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".colorPalette");
+    }
+}

package/lib/features/ConditionalFormatting.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class ConditionalFormatting {
+    static featureName = "Conditional Formatting";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/conditional-format";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".createDataViewWildcardSelector");
+    }
+}

package/lib/features/ContextMenu.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class ContextMenu {
+    static featureName = "Context Menu";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/context-menu";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".showContextMenu");
+    }
+}

package/lib/features/DrillDown.js

@@ -0,0 +1,16 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class DrillDown {
+    static featureName = "Drill Down";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/drill-down-support";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({
+            drilldown: {
+                roles: []
+            }
+        });
+    }
+}

package/lib/features/FeatureTypes.js

@@ -0,0 +1,23 @@
+export var Severity;
+(function (Severity) {
+    Severity["Error"] = "error";
+    Severity["Deprecation"] = "deprecation";
+    Severity["Warning"] = "warning";
+    Severity["Info"] = "info";
+})(Severity || (Severity = {}));
+export var Stage;
+(function (Stage) {
+    Stage["PreBuild"] = "pre-build";
+    Stage["PostBuild"] = "post-build";
+})(Stage || (Stage = {}));
+export var VisualFeatureType;
+(function (VisualFeatureType) {
+    VisualFeatureType[VisualFeatureType["NonSlicer"] = 2] = "NonSlicer";
+    VisualFeatureType[VisualFeatureType["Slicer"] = 4] = "Slicer";
+    VisualFeatureType[VisualFeatureType["Matrix"] = 8] = "Matrix";
+    VisualFeatureType[VisualFeatureType["All"] = 14] = "All";
+})(VisualFeatureType || (VisualFeatureType = {}));
+// Interaction types: Selection or filter (slicer)
+// Slicer type: Basic, Advanced, Tuple filter, Identity filter
+// Visual Type: TS/JS or R-Visual or RHTML
+// Dataview Type: Single or Matrix or Table or Category or All

package/lib/features/FetchMoreData.js

@@ -0,0 +1,22 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class FetchMoreData {
+    static featureName = "Fetch More Data";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/fetch-more-data";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({
+            dataViewMappings: [
+                {
+                    table: {
+                        rows: {
+                            dataReductionAlgorithm: {}
+                        }
+                    }
+                }
+            ]
+        });
+    }
+}

package/lib/features/FileDownload.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class FileDownload {
+    static featureName = "File Download";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/file-download-api";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".downloadService") && packageInstance.contain(".exportVisualsContent");
+    }
+}

package/lib/features/FormatPane.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class FormatPane {
+    static featureName = "Format Pane";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/format-pane";
+    static severity = Severity.Deprecation;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.All;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain("getFormattingModel");
+    }
+}

package/lib/features/HighContrast.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class HighContrast {
+    static featureName = "High Contrast";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/high-contrast-support";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".isHighContrast");
+    }
+}

package/lib/features/HighlightData.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class HighlightData {
+    static featureName = "Highlight Data";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/highlight";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({ supportsHighlight: true });
+    }
+}

package/lib/features/KeyboardNavigation.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class KeyboardNavigation {
+    static featureName = "Keyboard Navigation";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/supportskeyboardfocus-feature";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({ supportsKeyboardFocus: true });
+    }
+}

package/lib/features/LandingPage.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class LandingPage {
+    static featureName = "Landing Page";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/landing-page";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({ supportsLandingPage: true });
+    }
+}

package/lib/features/LaunchURL.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class LaunchURL {
+    static featureName = "Launch URL";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/launch-url";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".launchUrl");
+    }
+}

package/lib/features/LocalStorage.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class LocalStorage {
+    static featureName = "Local Storage";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/local-storage";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".storageService");
+    }
+}

package/lib/features/Localizations.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class Localizations {
+    static featureName = "Localizations";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/localization";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".createLocalizationManager");
+    }
+}

package/lib/features/ModalDialog.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class ModalDialog {
+    static featureName = "Modal Dialog";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/create-display-dialog-box";
+    static severity = Severity.Info;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer | VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.contain(".openModalDialog");
+    }
+}

package/lib/features/RenderingEvents.js

@@ -0,0 +1,13 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class RenderingEvents {
+    static featureName = "Rendering Events";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/event-service";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.All;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        const keywords = [".eventService", ".renderingStarted", ".renderingFinished"];
+        return !keywords.some(keyword => !packageInstance.contain(keyword));
+    }
+}

package/lib/features/SelectionAcrossVisuals.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class SelectionAcrossVisuals {
+    static featureName = "Selection Across Visuals";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/supportsmultivisualselection-feature";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.NonSlicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({ supportsMultiVisualSelection: true });
+    }
+}

package/lib/features/SyncSlicer.js

@@ -0,0 +1,12 @@
+import { Severity, Stage, VisualFeatureType } from "./FeatureTypes.js";
+export default class SyncSlicer {
+    static featureName = "Sync Slicer";
+    static documentationLink = "https://learn.microsoft.com/en-us/power-bi/developer/visuals/enable-sync-slicers";
+    static severity = Severity.Warning;
+    static stage = Stage.PostBuild;
+    static visualFeatureType = VisualFeatureType.Slicer;
+    static errorMessage = `${this.featureName} - ${this.documentationLink}`;
+    static isSupported(packageInstance) {
+        return packageInstance.isCapabilityEnabled({ supportsSynchronizingFilterState: true });
+    }
+}