@metricinsights/pp-dev 0.9.0 → 0.10.0

package/dist/cjs/plugin-DZS4Taov.js

@@ -1,1315 +0,0 @@
-'use strict';
-
-var httpProxyMiddleware = require('http-proxy-middleware');
-var url = require('url');
-var vite = require('vite');
-var picocolors = require('picocolors');
-var axios = require('axios');
-var jsdom = require('jsdom');
-var https = require('https');
-var memoryCache = require('memory-cache');
-var path = require('path');
-var fs = require('fs');
-var crypto = require('crypto');
-var process$1 = require('process');
-var child_process = require('child_process');
-var console = require('console');
-var zlib = require('zlib');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var memoryCache__namespace = /*#__PURE__*/_interopNamespaceDefault(memoryCache);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
-var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process$1);
-var child_process__namespace = /*#__PURE__*/_interopNamespaceDefault(child_process);
-var console__namespace = /*#__PURE__*/_interopNamespaceDefault(console);
-
-const urlReplacer = (originalHost, destinationHost, content) => {
-    const urlReplaceRegExp = new RegExp(`(!!)?(https?(:(\\\\)?/(\\\\)?/)${originalHost})`, 'gi');
-    return content.replace(urlReplaceRegExp, (substring, ...args) => {
-        if (substring.startsWith('!!')) {
-            return args[1];
-        }
-        return `http${args[2]}${destinationHost}`;
-    });
-};
-const urlPathReplacer = (urlPath, destinationPath, content) => {
-    const urlReplaceRegExp = new RegExp(`${urlPath.replace(/\\*\//gi, '\\\\/')}`, 'gi');
-    return content.replace(urlReplaceRegExp, destinationPath);
-};
-const redirect = (res, url, statusCode) => {
-    res.setHeader('location', url);
-    res.statusCode = statusCode;
-    res.end();
-};
-function cutUrlParams(url) {
-    const urlParts = url.split('?');
-    return urlParts[0];
-}
-
-// import pino from 'pino';
-// import { PrettyOptions } from 'pino-pretty';
-const storage = new Map();
-const DEFAULT_LOGGER_KEY = 'default';
-const createLogger = (level = 'info', name = DEFAULT_LOGGER_KEY) => {
-    if (storage.has(name)) {
-        return storage.get(name);
-    }
-    if (name === DEFAULT_LOGGER_KEY) {
-        const logger = vite.createLogger(level);
-        storage.set(name, logger);
-        return logger;
-    }
-    const logger = vite.createLogger(level);
-    storage.set(name, logger);
-    return logger;
-};
-
-const colors = picocolors.createColors();
-
-const hostOriginRegExp = /^(https?:\/\/)([^/]+)(\/.*)?$/i;
-const PROXY_HEADER = 'X-PP-Proxy';
-// TODO: Implement interceptor for streaming responses
-function streamResponseInterceptor(interceptor) {
-    return async (proxyRes, req, res) => {
-        res.setHeader(PROXY_HEADER, 1);
-        res.setHeaders(new Map(Object.entries(proxyRes.headers)));
-        proxyRes.pipe(res);
-    };
-}
-function initProxy(opts) {
-    const { rewritePath = /^\/(?!pt).*/i, baseURL = '', devServer, disableSSLValidation = false } = opts;
-    if (!baseURL) {
-        throw new Error('Base url is required');
-    }
-    const host = baseURL.replace(hostOriginRegExp, '$2');
-    const origin = baseURL.replace(hostOriginRegExp, '$1$2');
-    const fileType = import('file-type');
-    const logger = createLogger();
-    return httpProxyMiddleware.createProxyMiddleware({
-        /**
-         * IMPORTANT: avoid res.end being called automatically
-         **/
-        selfHandleResponse: true, // res.end() will be called internally by responseInterceptor()
-        pathFilter: (pathname, req) => {
-            if ((opts.proxyIgnore || []).some((value) => {
-                if (typeof value === 'string') {
-                    return pathname.startsWith(value);
-                }
-                else if (typeof value.test === 'function') {
-                    return value.test(pathname);
-                }
-                return true;
-            })) {
-                // Ignored paths
-                return false;
-            }
-            if (typeof rewritePath === 'string') {
-                return pathname.startsWith(rewritePath);
-            }
-            else if (Array.isArray(rewritePath)) {
-                return rewritePath.some((rP) => pathname.startsWith(rP));
-            }
-            else if (typeof rewritePath.test === 'function') {
-                return rewritePath.test(pathname);
-            }
-            return false;
-        },
-        target: baseURL,
-        changeOrigin: true,
-        autoRewrite: true,
-        cookieDomainRewrite: {
-            [host]: 'localhost',
-        },
-        logger: {
-            info: () => {
-                //
-            },
-            log: () => {
-                //
-            },
-            error: () => {
-                //
-            },
-            warn: () => {
-                //
-            },
-        },
-        secure: !disableSSLValidation,
-        headers: {
-            host,
-            origin,
-        },
-        on: {
-            proxyReq(proxyReq, req, res) {
-                const host = req.headers.host;
-                const referer = proxyReq.getHeader('referer');
-                logger.info(`${colors.blue('Proxies request:')} ${colors.green(req.method)} ${req.url} -> ${colors.green(proxyReq.method)} ${proxyReq.protocol}//${proxyReq.host}${proxyReq.path}`);
-                if (host && referer && typeof referer === 'string') {
-                    proxyReq.setHeader('referer', referer.replace(new RegExp(`https?://${host}`), baseURL));
-                }
-                req.socket.on('close', () => {
-                    setTimeout(() => {
-                        if (!proxyReq.destroyed) {
-                            proxyReq.destroy();
-                        }
-                    }, 200);
-                });
-                return proxyReq;
-            },
-            proxyRes: (serverRes, req, res) => {
-                if (serverRes.headers['content-type']?.includes('text/event-stream') ||
-                    (serverRes.headers['transfer-encoding']?.includes('chunked') &&
-                        serverRes.headers['x-accel-buffering'] === 'no')) {
-                    logger.info(`${colors.blue('Start streaming for request:')} ${colors.green(req.method)} ${req.url}`);
-                    const streamInterceptor = streamResponseInterceptor();
-                    return streamInterceptor(serverRes, req, res);
-                }
-                const rewriteInterceptor = httpProxyMiddleware.responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
-                    res.setHeader(PROXY_HEADER, 1);
-                    const type = await (await fileType).fileTypeFromBuffer(responseBuffer);
-                    if (type) {
-                        return responseBuffer;
-                    }
-                    else {
-                        let response = responseBuffer.toString('utf8'); // convert buffer to string
-                        try {
-                            const reqUrl = new URL(req.url ?? '', `http://${host}`);
-                            if (reqUrl.searchParams && reqUrl.searchParams.has('proxyRedirect')) {
-                                const redirectToFunction = function () {
-                                    let url = window.location.href;
-                                    const func = function () {
-                                        const params = new URLSearchParams(window.location.search);
-                                        if (!params.has('proxyRedirect')) {
-                                            return;
-                                        }
-                                        if (url !== window.location.href) {
-                                            url = window.location.href;
-                                            setTimeout(func, 2000);
-                                        }
-                                        else {
-                                            window.location.href = params.get('proxyRedirect');
-                                        }
-                                    };
-                                    setTimeout(func, 2000);
-                                };
-                                response += '<script>' + `(${redirectToFunction.toString()})()` + '</script>';
-                            }
-                        }
-                        catch {
-                            //
-                        }
-                        const reqHost = req.headers.host ?? '';
-                        // manipulate response and return the result
-                        return urlPathReplacer('/auth/saml/login', '/login', urlReplacer(host, reqHost, response));
-                    }
-                });
-                return rewriteInterceptor(serverRes, req, res);
-            },
-            error(err, req, res) {
-                const errorMessage = `Proxy error: "${err.message}" when trying to "${req.method} ${req.url}"\n\n${err.stack}`;
-                logger.error(errorMessage);
-                if (res.writable) {
-                    res.writeHead(500, {
-                        'Content-Type': 'text/plain',
-                    });
-                }
-                res.end(errorMessage);
-            },
-        },
-    });
-}
-
-class BaseAPI {
-    axios;
-    constructor(axios) {
-        this.axios = axios;
-    }
-    async checkAuth(headers) {
-        return this.axios
-            .get('/data/page/index/auth/info', {
-            headers: Object.assign({}, headers, { accept: 'text/html' }),
-            maxRedirects: 0,
-        })
-            .then(() => true)
-            .catch(() => false);
-    }
-}
-
-class AssetsAPI extends BaseAPI {
-    // Import for CJS and ESM
-    formdataModulePromise = import('formdata-node');
-    constructor(axios) {
-        super(axios);
-    }
-    getDownloadUrl(portalPageId) {
-        return `/admin/page/downloadassets/id/${portalPageId}`;
-    }
-    getDownloadTemplateUrl(templateId) {
-        return `/admin/pagetemplate/downloadassets/id/${templateId}`;
-    }
-    getUploadUrl(portalPageId) {
-        return `/admin/page/uploadassets/id/${portalPageId}`;
-    }
-    getUploadTemplateUrl(templateId) {
-        return `/admin/pagetemplate/uploadassets/id/${templateId}`;
-    }
-    async downloadPageAssets(portalPageId, headers) {
-        return this.axios
-            .get(this.getDownloadUrl(portalPageId), {
-            withCredentials: true,
-            headers: Object.assign({}, headers, { accept: '*/*' }),
-            responseType: 'arraybuffer',
-        })
-            .then((res) => res.data);
-    }
-    /**
-     * Upload page assets.
-     * @param portalPageId
-     * @param file - Zip file with assets
-     * @param headers
-     */
-    async uploadPageAssets(portalPageId, file, headers) {
-        const formData = new (await this.formdataModulePromise).FormData();
-        const assetFile = new File([file.buffer], 'file.zip', { type: 'application/zip' });
-        formData.append('file', assetFile);
-        const url = this.getUploadUrl(portalPageId);
-        return this.axios
-            .post(url, formData, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'application/json',
-                'Content-Type': 'multipart/form-data',
-                Referer: this.axios.getUri({ url }),
-            }),
-        })
-            .then((res) => res.data);
-    }
-    async downloadTemplateAssets(templateId, headers) {
-        return this.axios
-            .get(this.getDownloadTemplateUrl(templateId), {
-            withCredentials: true,
-            headers: Object.assign({}, headers, { accept: '*/*' }),
-            responseType: 'arraybuffer',
-        })
-            .then((res) => res.data);
-    }
-    /**
-     * Upload template assets.
-     * @param templateId
-     * @param file - Zip file with assets
-     * @param headers
-     */
-    async uploadTemplateAssets(templateId, file, headers) {
-        const formData = new (await this.formdataModulePromise).FormData();
-        const assetFile = new (await this.formdataModulePromise).File([file.buffer], 'file.zip', {
-            type: 'application/zip',
-        });
-        formData.append('file', assetFile, 'file.zip');
-        const url = this.getUploadTemplateUrl(templateId);
-        return this.axios
-            .post(url, formData, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'application/json',
-                'Content-Type': 'multipart/form-data',
-                Referer: this.axios.getUri({ url }),
-            }),
-        })
-            .then((res) => res.data);
-    }
-}
-class AssetsV7API extends AssetsAPI {
-    getDownloadUrl(portalPageId) {
-        return `/api/page/id/${portalPageId}/asset/download`;
-    }
-    getDownloadTemplateUrl(templateId) {
-        return `/api/page_template/id/${templateId}/asset/download`;
-    }
-    getUploadUrl(portalPageId) {
-        return `/api/page/id/${portalPageId}/asset/upload`;
-    }
-    getUploadTemplateUrl(templateId) {
-        return `/api/page_template/id/${templateId}/asset/upload`;
-    }
-}
-
-class PageAPI extends BaseAPI {
-    async getAll(headers) {
-        return (await this.axios.get('/api/page', {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-                'Cache-Control': 'no-cache',
-                Pragma: 'no-cache',
-                Expires: '0',
-            }),
-        })).data.pages;
-    }
-    async get(id, headers) {
-        return (await this.axios.get(`/api/page/id/${id}`, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'application/json',
-                'content-type': 'application/json',
-            }),
-        })).data.page;
-    }
-    async getPageContent(internalPageName, headers) {
-        return (await this.axios.get(`/p/${internalPageName}`, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'text/html',
-                'content-type': 'application/json',
-            }),
-        })).data;
-    }
-    async create(page, headers) {
-        return (await this.axios.post('/api/page', page, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'application/json',
-                'content-type': 'application/json',
-            }),
-        })).data.page;
-    }
-}
-
-class PageTemplateAPI extends BaseAPI {
-    async getAll(internal_name, headers) {
-        return (await this.axios.get(`/api/page_template`, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                Accept: 'application/json',
-                'Content-Type': 'application/json',
-                'Cache-Control': 'no-cache',
-                Pragma: 'no-cache',
-                Expires: '0',
-            }),
-            params: {
-                internal_name,
-            },
-        })).data.page_templates;
-    }
-    async get(id, headers) {
-        return (await this.axios.get(`/api/page_template/id/${id}`, {
-            withCredentials: true,
-            headers: Object.assign({}, headers, {
-                accept: 'application/json',
-                'content-type': 'application/json',
-            }),
-        })).data.page_template;
-    }
-}
-
-const TEMPLATE_PAGE_NAME = '[DEV PAGE. DO NOT DELETE]';
-class MiAPI {
-    #headers;
-    #axios;
-    #pageTemplate = null;
-    #pageTitle;
-    #pageVars;
-    #v7Features;
-    #isV710OrHigher;
-    #templateLoaded;
-    #templateLoadedResolve;
-    portalPageId;
-    templateLess;
-    assetsApi;
-    pageApi;
-    pageTemplateApi;
-    logger;
-    constructor(baseURL, opts) {
-        const { headers = {}, portalPageId, templateLess = true, disableSSLValidation = false, v7Features = false, } = opts || {};
-        this.#headers = headers;
-        this.#pageVars = [];
-        this.#pageTitle = '';
-        this.#v7Features = v7Features;
-        this.#isV710OrHigher = false;
-        this.#templateLoaded = Promise.resolve(false);
-        if (disableSSLValidation) {
-            axios.defaults.httpsAgent = new https.Agent({ rejectUnauthorized: false });
-        }
-        this.#axios = axios.create({
-            baseURL,
-            headers,
-        });
-        this.portalPageId = portalPageId;
-        this.templateLess = templateLess;
-        this.assetsApi = new (!v7Features ? AssetsAPI : AssetsV7API)(this.#axios);
-        this.pageApi = new PageAPI(this.#axios);
-        this.pageTemplateApi = new PageTemplateAPI(this.#axios);
-        this.logger = createLogger();
-    }
-    async isTemplateLoaded() {
-        return this.#templateLoaded;
-    }
-    get isV710OrHigher() {
-        return this.#isV710OrHigher;
-    }
-    #clearHeaders(headers) {
-        const obj = Object.assign({}, headers, { host: undefined, referer: undefined });
-        Object.keys(obj).forEach((key) => obj[key] === undefined && delete obj[key]);
-        this.#headers = obj;
-        return obj;
-    }
-    updateHeaders(headers) {
-        this.#clearHeaders(headers);
-    }
-    get localTemplateHTML() {
-        return /* HTML */ `<!DOCTYPE html>
-      <html lang="en">
-        <head>
-          <meta charset="UTF-8" />
-          <title>Local template</title>
-          <meta charset="UTF-8" />
-          <link rel="icon" type="image/svg+xml" href="/favicon.ico" />
-          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        </head>
-        <body>
-          <div id="mi-react-root"></div>
-          <script src="/auth/info.js"></script>
-          <script src="/js/main.js" defer></script>
-          <link rel="stylesheet" href="/css/main.css" />
-        </body>
-      </html>`;
-    }
-    /**
-     * Get page template
-     * @param headers
-     */
-    async getPageTemplate(headers) {
-        if (!(await this.#templateLoaded) && !this.#pageTemplate) {
-            this.#templateLoaded = new Promise((resolve) => {
-                this.#templateLoadedResolve = resolve;
-            });
-        }
-        if (this.#pageTemplate) {
-            return Promise.resolve(this.#pageTemplate);
-        }
-        if (typeof this.templateLess === 'undefined') {
-            this.templateLess = false;
-        }
-        if (this.#v7Features) {
-            const page = await this.pageApi
-                .get(this.portalPageId, this.#clearHeaders(headers))
-                .then((response) => {
-                this.logger.info(colors.green('Page fetched'));
-                return response;
-            })
-                .catch(async (e) => {
-                this.#templateLoadedResolve(false);
-                if (await this.pageApi.checkAuth(this.#clearHeaders(headers))) {
-                    this.logger.error(colors.red(`Error fetching page data: ${e.message}\n${e.stack}`));
-                    throw new Error('Current user does not have access to the page');
-                }
-                else {
-                    throw e;
-                }
-            });
-            if (typeof page.template_id !== 'undefined') {
-                this.#isV710OrHigher = true;
-            }
-            this.#pageTemplate = this.localTemplateHTML;
-            this.logger.info(colors.green('Local page template fetched'));
-            this.#templateLoadedResolve(true);
-            return this.#pageTemplate;
-        }
-        const pageList = await this.pageApi
-            .getAll(this.#clearHeaders(headers))
-            .then((response) => {
-            this.logger.info(colors.green('Page list fetched'));
-            return response;
-        })
-            .catch(async (e) => {
-            this.#templateLoadedResolve(false);
-            if (await this.pageApi.checkAuth(this.#clearHeaders(headers))) {
-                this.logger.error(colors.red(`Error fetching page list: ${e.message}\n${e.stack}`));
-                throw new Error('Current user does not have access to page list');
-            }
-            else {
-                throw e;
-            }
-        });
-        let page = pageList.find((p) => p.name === TEMPLATE_PAGE_NAME);
-        if (!page) {
-            this.logger.warn(colors.yellow('Creating dev page template...'));
-            page = await this.pageApi
-                .create({
-                enabled: 'Y',
-                name: TEMPLATE_PAGE_NAME,
-                internal_name: 'dev-page-template',
-                visible_in_homepage: 'Y',
-            }, this.#clearHeaders(headers))
-                .then((response) => {
-                this.logger.info(colors.green('Dev page created'));
-                return response;
-            })
-                .catch((e) => {
-                this.logger.error(colors.red(`Error creating dev page: ${e.message}`));
-                this.#templateLoadedResolve(false);
-                throw new Error(`Error when creating dev page.
-            That can be caused by missing permissions or page with name "${TEMPLATE_PAGE_NAME}" already exists`);
-            });
-        }
-        return await this.pageApi
-            .getPageContent(page.internal_name, this.#clearHeaders(headers))
-            .then((response) => {
-            this.#pageTemplate = response;
-            return response;
-        })
-            .then((response) => {
-            this.#templateLoadedResolve(true);
-            this.logger.info(colors.green('Page template fetched'));
-            return response;
-        })
-            .catch((e) => {
-            this.#templateLoadedResolve(false);
-            this.logger.error(colors.red(`Error fetching page template: ${e.message}`));
-            throw new Error('Error fetching page template');
-        });
-    }
-    /**
-     * Get page template variables
-     *
-     * @param pageId
-     * @param headers
-     */
-    async getPageVariables(pageId, headers) {
-        this.#pageTemplate = await this.getPageTemplate(headers);
-        if (!this.portalPageId) {
-            this.portalPageId = pageId;
-            this.templateLess = false;
-        }
-        return await this.pageApi
-            .get(pageId, this.#clearHeaders(headers))
-            .then((response) => {
-            const { tags = '[]', name, template } = response;
-            if (template && tags) {
-                const parsed = JSON.parse(tags);
-                this.#pageVars = parsed;
-                this.#pageTitle = name;
-                return parsed;
-            }
-            this.#pageVars = [];
-            this.#pageTitle = name;
-            return [];
-        })
-            .catch((reason) => {
-            this.logger.error(colors.red(`Error fetching page variables: ${reason.message}`));
-            if (reason.response?.status === 404) {
-                throw new Error(`Portal Page with id "${pageId}" not found on instance ${this.#axios.getUri()}`);
-            }
-            if (reason.response?.status === 401) {
-                throw new Error(`Current user does not have access to page with id "${pageId}" on instance ${this.#axios.getUri()}`);
-            }
-            throw reason;
-        });
-    }
-    /**
-     * Build page with variables
-     *
-     * @param content
-     * @param miHudLess
-     */
-    buildPage(content, miHudLess = false) {
-        let result = typeof content === 'string' ? content : content.toString('utf-8');
-        for (const v of this.#pageVars) {
-            result = result.replace(new RegExp(`\\[${v.name}\\]`, 'g'), v.value);
-        }
-        const dom = new jsdom.JSDOM(miHudLess ? result : this.#pageTemplate);
-        const placeholderText = '%%PLACEHOLDER%%';
-        if (!miHudLess) {
-            const placeholder = dom.window.document.createElement('div');
-            placeholder.innerHTML = placeholderText;
-            const container = dom.window.document.querySelector('.main-side');
-            if (container) {
-                const scripts = container.querySelectorAll('script');
-                if (scripts.length) {
-                    container.insertBefore(placeholder, scripts.item(scripts.length - 1));
-                }
-                else {
-                    container.append(placeholder);
-                }
-            }
-            else {
-                const container = dom.window.document.createElement('div');
-                container.append(placeholder);
-                dom.window.document.body.append(container);
-            }
-            const head = dom.window.document.querySelector('head');
-            const title = head.querySelector('title');
-            if (title) {
-                title.text = this.#pageTitle;
-            }
-            else {
-                head.innerHTML += `<title>${this.#pageTitle}</title>`;
-            }
-        }
-        const serializedDom = dom.serialize();
-        return serializedDom.replace(new RegExp(`<div>\\s*${placeholderText}\\s*<\\/div>`, 'i'), result);
-    }
-    async getAssets() {
-        if (this.portalPageId) {
-            if (this.templateLess) {
-                return await this.assetsApi.downloadPageAssets(this.portalPageId, this.#headers);
-            }
-            else {
-                const pageInfo = await this.pageApi.get(this.portalPageId, this.#headers);
-                if (this.#isV710OrHigher) {
-                    const templateInfo = await this.pageTemplateApi.get(pageInfo.template_id, this.#headers);
-                    return await this.assetsApi.downloadTemplateAssets(templateInfo.id, this.#headers);
-                }
-                else {
-                    if (pageInfo.template) {
-                        return await this.assetsApi.downloadTemplateAssets(pageInfo.template, this.#headers);
-                    }
-                }
-            }
-        }
-    }
-    async updateAssets(assets) {
-        if (this.portalPageId) {
-            if (this.templateLess) {
-                return await this.assetsApi.uploadPageAssets(this.portalPageId, assets, this.#headers);
-            }
-            else {
-                const pageInfo = await this.pageApi.get(this.portalPageId, this.#headers);
-                if (this.#isV710OrHigher) {
-                    const templateInfo = await this.pageTemplateApi.get(pageInfo.template_id, this.#headers);
-                    return await this.assetsApi.uploadTemplateAssets(templateInfo.id, assets, this.#headers);
-                }
-                else {
-                    if (pageInfo.template) {
-                        return await this.assetsApi.uploadTemplateAssets(pageInfo.template, assets, this.#headers);
-                    }
-                }
-            }
-        }
-    }
-}
-
-class ClientService {
-    server;
-    opts;
-    eventMap;
-    logger;
-    constructor(server, opts) {
-        this.server = server;
-        this.opts = opts || {};
-        this.eventMap = new Map();
-        this.eventMap.set('info-data:request', this.onInfoDataRequest.bind(this));
-        this.eventMap.set('template:sync', this.onTemplateSync.bind(this));
-        this.logger = createLogger();
-        this.init();
-    }
-    init() {
-        const { ws } = this.server;
-        for (const [event, handler] of this.eventMap) {
-            ws.on(event, handler);
-        }
-    }
-    onInfoDataRequest() {
-        this.server.ws.send({
-            type: 'custom',
-            event: 'info-data:response',
-            data: {},
-        });
-    }
-    async onTemplateSync() {
-        if (this.opts.distService && this.opts.miAPI) {
-            const { distService, miAPI } = this.opts;
-            if (this.server.config.clientInjectionPlugin?.v7Features) {
-                if (!miAPI?.isV710OrHigher) {
-                    this.server.ws.send('template:sync:response', {
-                        error: 'This feature is available only for MI v7.1.0 or higher',
-                        config: {
-                            canSync: false,
-                        },
-                    });
-                    return;
-                }
-                else {
-                    this.server.ws.send('client:config:update', {
-                        config: {
-                            canSync: true,
-                        },
-                    });
-                }
-            }
-            const currentAssets = await miAPI?.getAssets();
-            const newAssets = currentAssets
-                ? await distService?.saveBackupAndBuild(currentAssets)
-                : await distService?.buildNewAssets();
-            if (newAssets) {
-                const updateResult = await miAPI?.updateAssets(newAssets);
-                if (updateResult?.status === 'OK') {
-                    const backupMeta = distService?.getBackupMeta();
-                    const { lastBackupName: backupFilename, lastBackupHash: currentHash, lastBackupDate: backupDate, } = backupMeta || { lastBackupName: '', lastBackupHash: '', lastBackupDate: new Date().toISOString() };
-                    this.server.ws.send('template:sync:response', {
-                        syncedAt: new Date(backupDate),
-                        currentHash,
-                        backupFilename,
-                    });
-                    this.logger.info(colors.green('Template synced'));
-                }
-                else {
-                    this.server.ws.send('template:sync:response', { error: 'Failed to update assets' });
-                    this.logger.error(colors.red('Failed to update assets'));
-                }
-            }
-            else {
-                this.server.ws.send('template:sync:response', { error: 'Failed to build new assets' });
-                this.logger.error(colors.red('Failed to build new assets'));
-                return;
-            }
-        }
-        else {
-            this.server.ws.send('template:sync:response', { error: 'Dist service or MiAPI is not defined' });
-            this.logger.error(colors.red('Dist service or MiAPI is not defined'));
-            return;
-        }
-    }
-}
-
-const cache = new memoryCache__namespace.Cache();
-const testCacheUrlRegExp = /\.[a-z0-9]+$/i;
-function initProxyCache(opts) {
-    const { devServer, ttl = 10 * 60 * 1000 } = opts;
-    const logger = createLogger();
-    devServer.cache = cache;
-    return (req, res, next) => {
-        const url = req.originalUrl || req.url || '';
-        if (testCacheUrlRegExp.test(url.split('?')[0] || '')) {
-            const cacheItem = cache.get(url);
-            if (cacheItem) {
-                logger.info(`${colors.blue('Proxies request:')} ${colors.green(req.method)} ${url} -> ${colors.blue('Cache')} ${url}`);
-                for (const [header, value] of Object.entries(cacheItem.headers)) {
-                    res.setHeader(header, value);
-                }
-                res.write(cacheItem.content);
-                res.end();
-                return;
-            }
-            const end = res.end;
-            const write = res.write;
-            let buffer = Buffer.from('', 'utf8');
-            // Rewrite response method and get the content.
-            res.write = function (data, encoding, callback) {
-                if (!res.hasHeader(PROXY_HEADER)) {
-                    return write.call(this, data, encoding, callback);
-                }
-                buffer = Buffer.concat([buffer, data]);
-                return true;
-            };
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            res.end = function (chunk, encoding, cb) {
-                if (!res.hasHeader(PROXY_HEADER)) {
-                    return end.call(this, chunk, encoding, cb);
-                }
-                if (typeof chunk === 'string') {
-                    buffer = Buffer.concat([buffer, Buffer.from(chunk, encoding)]);
-                }
-                if (Buffer.isBuffer(chunk)) {
-                    buffer = Buffer.concat([buffer, chunk]);
-                }
-                if (res.hasHeader(PROXY_HEADER)) {
-                    logger.info(`${colors.blue('[Cached]')} ${url}`);
-                    cache.put(url, { headers: res.getHeaders(), content: buffer }, ttl);
-                }
-                end.call(this, buffer, encoding, cb);
-            };
-        }
-        next();
-    };
-}
-
-const TEMPLATE_PART_PAGE_NAME = 'pageName';
-const TEMPLATE_PART_DATE = 'date';
-const DIRNAME = path__namespace.dirname((typeof __filename !== 'undefined' && __filename) || url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin-DZS4Taov.js', document.baseURI).href))));
-const pluginPath = path__namespace.resolve(DIRNAME, '..', '..');
-const node_modules_path = path__namespace.resolve(pluginPath, '..', '..');
-const metaDirName = '.pp-dev-meta';
-const metaDirPath = path__namespace.resolve(node_modules_path, metaDirName);
-const metaFilePath = path__namespace.resolve(metaDirPath, 'sync-service.meta.json');
-class DistService {
-    backupFolder;
-    backupNameTemplate;
-    dateFormat;
-    pageName;
-    currentMeta = null;
-    distZipFolder;
-    distZipFilename;
-    logger;
-    constructor(pageName, syncOptions) {
-        this.pageName = pageName;
-        const { backupFolder = path__namespace.resolve(process__namespace.cwd(), 'backups'), distZipFolder = path__namespace.resolve(process__namespace.cwd(), 'dist-zip'), distZipFilename = `${this.pageName}.zip`, backupNameTemplate = `{${TEMPLATE_PART_PAGE_NAME}}-{${TEMPLATE_PART_DATE}}.zip`, dateFormat = (date) => date.toISOString().replace(/:/g, '-').replace(/\..*$/, ''), } = syncOptions || {};
-        this.backupFolder = backupFolder;
-        this.backupNameTemplate = backupNameTemplate;
-        this.dateFormat = dateFormat;
-        this.distZipFolder = distZipFolder;
-        this.distZipFilename = distZipFilename;
-        this.syncMeta();
-        this.logger = createLogger();
-    }
-    async checkMeta() {
-        try {
-            await fs.promises.stat(metaDirPath);
-        }
-        catch {
-            await fs.promises.mkdir(metaDirPath);
-        }
-        try {
-            await fs.promises.stat(this.backupFolder);
-        }
-        catch {
-            await fs.promises.mkdir(this.backupFolder);
-        }
-    }
-    async readMetaFile() {
-        await this.checkMeta();
-        return await fs.promises
-            .readFile(metaFilePath, {
-            encoding: 'utf-8',
-        })
-            .catch(() => '{}');
-    }
-    async writeMetaFile(meta) {
-        await this.checkMeta();
-        return await fs.promises.writeFile(metaFilePath, JSON.stringify(meta, null, 2), {
-            encoding: 'utf-8',
-        });
-    }
-    async syncMeta() {
-        if (!this.currentMeta) {
-            this.currentMeta = JSON.parse(await this.readMetaFile());
-        }
-        else {
-            await this.writeMetaFile(this.currentMeta);
-        }
-    }
-    async getLatestSavedBackup() {
-        const { lastBackupName } = this.currentMeta;
-        if (!lastBackupName) {
-            return null;
-        }
-        const backupPath = path__namespace.resolve(this.backupFolder, lastBackupName);
-        try {
-            await fs.promises.stat(backupPath);
-            return backupPath;
-        }
-        catch {
-            return null;
-        }
-    }
-    backupName(pageName, date = new Date()) {
-        return this.backupNameTemplate
-            .replace(`{${TEMPLATE_PART_PAGE_NAME}}`, pageName)
-            .replace(`{${TEMPLATE_PART_DATE}}`, this.dateFormat(date));
-    }
-    getBackupMeta() {
-        return this.currentMeta;
-    }
-    async saveBackup(backupFile) {
-        const backupFileHash = crypto__namespace.createHash('md5').update(backupFile).digest('hex');
-        const lastSavedBackup = await this.getLatestSavedBackup();
-        if (lastSavedBackup) {
-            const { lastBackupHash } = this.currentMeta;
-            if (lastBackupHash === backupFileHash) {
-                return;
-            }
-        }
-        const backupDate = new Date();
-        const filename = this.backupName(this.pageName, backupDate);
-        this.currentMeta.lastBackupName = filename;
-        this.currentMeta.lastBackupHash = backupFileHash;
-        this.currentMeta.lastBackupDate = backupDate.toISOString();
-        await this.syncMeta();
-        return await fs.promises.writeFile(path__namespace.resolve(this.backupFolder, filename), backupFile).finally(() => {
-            this.logger.info(`Backup saved to ${filename}`);
-        });
-    }
-    async buildNewAssets() {
-        const buildCommand = new Promise((resolve, reject) => {
-            let data = '';
-            // Colorized log output with message about build start
-            this.logger.info(colors.cyan('[DistService] Build started'));
-            const proc = child_process__namespace.spawn('node', [path__namespace.resolve(pluginPath, './bin/pp-dev.js'), 'build'], {
-                cwd: process__namespace.cwd(),
-                env: Object.assign({}, process__namespace.env, { NODE_ENV: 'production' }),
-                stdio: 'inherit',
-            });
-            proc.on('message', (msg) => {
-                data += msg;
-            });
-            proc.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`build command exited with code ${code}`));
-                    return;
-                }
-                resolve(data);
-            });
-            proc.on('error', (err) => {
-                reject(err);
-            });
-        });
-        try {
-            await buildCommand.finally(() => {
-                // Colorized log output with message about build end
-                this.logger.info(colors.cyan('[DistService] Build finished'));
-            });
-            const assetFile = path__namespace.resolve(process__namespace.cwd(), this.distZipFolder, this.distZipFilename);
-            if (!(await fs.promises.stat(assetFile))) {
-                throw new Error(`File ${assetFile} not found`);
-            }
-            return await fs.promises.readFile(assetFile);
-        }
-        catch (e) {
-            console__namespace.log(e);
-            throw e;
-        }
-    }
-    async saveBackupAndBuild(backupFile) {
-        await this.saveBackup(backupFile);
-        return await this.buildNewAssets();
-    }
-}
-
-function decodeContent(content, contentEncoding) {
-    switch (contentEncoding) {
-        case 'gzip':
-            return zlib.unzipSync(content);
-        case 'br':
-            return zlib.brotliDecompressSync(content);
-        case 'deflate':
-            return zlib.deflateSync(content);
-        default:
-            return content;
-    }
-}
-function encodeContent(content, contentEncoding) {
-    switch (contentEncoding) {
-        case 'gzip':
-            return zlib.gzipSync(content);
-        case 'br':
-            return zlib.brotliCompressSync(content);
-        case 'deflate':
-            return zlib.inflateSync(content);
-        default:
-            return content;
-    }
-}
-
-/**
- * Rewrite response middleware
- *
- * @param predicate Check if need to rewrite response data
- * @param rewrite Rewrite response content handler
- */
-function initRewriteResponse(predicate, rewrite) {
-    return async (req, res, next) => {
-        if (await predicate(req.url ?? '', req, res)) {
-            const logger = createLogger();
-            logger.info(`Rewrite response for ${req.url}`);
-            const end = res.end;
-            const buffers = [];
-            res.write = function (body) {
-                buffers.push(body);
-                return true;
-            };
-            res.end = function (chunk, encoding, cb) {
-                if (typeof chunk === 'string') {
-                    buffers.push(Buffer.from(chunk));
-                }
-                const contentEncoding = res.getHeader('content-encoding');
-                const content = decodeContent(Buffer.from(Buffer.concat(buffers)), contentEncoding);
-                const bufferEncoding = typeof encoding !== 'function' && encoding ? encoding : 'utf-8';
-                const endCallback = typeof encoding === 'function' ? encoding : cb;
-                end.call(this, encodeContent(rewrite(content, req, res), contentEncoding), bufferEncoding, endCallback);
-                return this;
-            };
-        }
-        next();
-    };
-}
-
-function initPPRedirect(base, templateName) {
-    base = base.startsWith('/') ? base : `/${base}`;
-    base = base.endsWith('/') ? base : `${base}/`;
-    const baseWithoutTrailingSlash = base.endsWith('/') ? base.slice(0, -1) : base;
-    const logger = createLogger();
-    return (req, res, next) => {
-        const parsedUrl = new url.URL(req.url ?? '', 'http://localhost');
-        const { pathname, search } = parsedUrl;
-        const findPaths = ['/', baseWithoutTrailingSlash];
-        if (templateName) {
-            findPaths.push(`/pt/${templateName}`);
-            findPaths.push(`/pl/${templateName}`);
-        }
-        // Redirect from `/` and `/pt/${templateName}` and `${base}` (without a training slash) to portal page address
-        if (findPaths.includes(pathname)) {
-            const redirectUrl = `${base}${search}`;
-            logger.info(colors.yellow(`Redirecting to: ${redirectUrl}`));
-            return redirect(res, redirectUrl, 302);
-        }
-        next();
-    };
-}
-
-function initLoadPPData(applyUrlRegExp, mi, opts) {
-    const { templateLess = false, miHudLess = false, portalPageId } = opts;
-    const logger = createLogger();
-    return (req, res, next) => {
-        const isNeedTemplateLoad = !(templateLess && miHudLess);
-        const isApplyRequest = applyUrlRegExp.test(cutUrlParams(req.url ?? ''));
-        if (isNeedTemplateLoad && isApplyRequest) {
-            const headers = (req.headers ?? {});
-            logger.info(colors.green(`Start loading page data`));
-            const loadPageData = !templateLess && typeof portalPageId !== 'undefined'
-                ? mi.getPageVariables(portalPageId, headers)
-                : mi.getPageTemplate(headers);
-            loadPageData
-                .then(() => {
-                next();
-            })
-                .catch((reason) => {
-                if (reason.response) {
-                    logger.info(colors.red('Page data loading failed. Not authorized'));
-                    const redirectUrl = `/home?proxyRedirect=${encodeURIComponent('/')}`;
-                    logger.info(colors.yellow(`Redirecting to: ${redirectUrl}`));
-                    return redirect(res, redirectUrl, 302);
-                }
-                logger.info(colors.red(`Page data loading failed. Error: ${reason.message}`));
-                next(reason);
-            });
-        }
-        else {
-            next();
-        }
-    };
-}
-
-function isVitePPDevOptions(options) {
-    return (typeof options === 'object' &&
-        typeof options.templateName === 'string' &&
-        (typeof options.backendBaseURL === 'string' || options.backendBaseURL === undefined) &&
-        (typeof options.portalPageId === 'number' || options.portalPageId === undefined) &&
-        (typeof options.templateLess === 'boolean' || options.templateLess === undefined) &&
-        (typeof options.miHudLess === 'boolean' || options.miHudLess === undefined) &&
-        (typeof options.enableProxyCache === 'boolean' || options.enableProxyCache === undefined) &&
-        (typeof options.proxyCacheTTL === 'number' || options.proxyCacheTTL === undefined) &&
-        (typeof options.disableSSLValidation === 'boolean' || options.disableSSLValidation === undefined) &&
-        (typeof options.imageOptimizer === 'boolean' ||
-            typeof options.imageOptimizer === 'object' ||
-            options.imageOptimizer === undefined) &&
-        (typeof options.outDir === 'string' || options.outDir === undefined) &&
-        (typeof options.distZip === 'boolean' || typeof options.distZip === 'object' || options.distZip === undefined) &&
-        (typeof options.syncBackupsDir === 'string' || options.syncBackupsDir === undefined) &&
-        (typeof options.v7Features === 'boolean' || options.v7Features === undefined));
-}
-function throwConfigError(config) {
-    if (typeof config !== 'object') {
-        throw new Error('VitePPDevOptions must be an object');
-    }
-    if (typeof config.templateName !== 'string') {
-        throw new Error('VitePPDevOptions.templateName must be a string');
-    }
-    if (config.backendBaseURL !== undefined && typeof config.backendBaseURL !== 'string') {
-        throw new Error('VitePPDevOptions.backendBaseURL must be a string');
-    }
-    if (config.portalPageId !== undefined && typeof config.portalPageId !== 'number') {
-        throw new Error('VitePPDevOptions.portalPageId must be a number');
-    }
-    if (config.templateLess !== undefined && typeof config.templateLess !== 'boolean') {
-        throw new Error('VitePPDevOptions.templateLess must be a boolean');
-    }
-    if (config.miHudLess !== undefined && typeof config.miHudLess !== 'boolean') {
-        throw new Error('VitePPDevOptions.miHudLess must be a boolean');
-    }
-    if (config.enableProxyCache !== undefined && typeof config.enableProxyCache !== 'boolean') {
-        throw new Error('VitePPDevOptions.enableProxyCache must be a boolean');
-    }
-    if (config.proxyCacheTTL !== undefined && typeof config.proxyCacheTTL !== 'number') {
-        throw new Error('VitePPDevOptions.proxyCacheTTL must be a number');
-    }
-    if (config.disableSSLValidation !== undefined && typeof config.disableSSLValidation !== 'boolean') {
-        throw new Error('VitePPDevOptions.disableSSLValidation must be a boolean');
-    }
-    if (config.imageOptimizer !== undefined &&
-        typeof config.imageOptimizer !== 'boolean' &&
-        typeof config.imageOptimizer !== 'object') {
-        throw new Error('VitePPDevOptions.imageOptimizer must be a boolean or an object');
-    }
-    if (config.outDir !== undefined && typeof config.outDir !== 'string') {
-        throw new Error('VitePPDevOptions.outDir must be a string');
-    }
-    if (config.distZip !== undefined && typeof config.distZip !== 'boolean' && typeof config.distZip !== 'object') {
-        throw new Error('VitePPDevOptions.distZip must be a boolean or an object');
-    }
-    if (config.syncBackupsDir !== undefined && typeof config.syncBackupsDir !== 'string') {
-        throw new Error('VitePPDevOptions.syncBackupsDir must be a string');
-    }
-    if (config.v7Features !== undefined && typeof config.v7Features !== 'boolean') {
-        throw new Error('VitePPDevOptions.v7Features must be a boolean');
-    }
-}
-function normalizeVitePPDevConfig(config) {
-    !isVitePPDevOptions(config) && throwConfigError(config);
-    const { enableProxyCache = true, proxyCacheTTL = 10 * 60 * 1000, disableSSLValidation = false, imageOptimizer = true, miHudLess = false, templateLess = false, outDir = 'dist', distZip = true, syncBackupsDir = 'backups', v7Features = false, } = config || {};
-    let distZipConfig = distZip;
-    if (distZipConfig === true) {
-        distZipConfig = {
-            outFileName: `${config.templateName}.zip`,
-            outDir: 'dist-zip',
-        };
-    }
-    else if (typeof distZip === 'object') {
-        distZipConfig = {
-            outFileName: typeof distZip.outFileName === 'string'
-                ? distZip.outFileName.replace('[templateName]', config.templateName)
-                : `${config.templateName}.zip`,
-            outDir: distZip.outDir ?? 'dist-zip',
-        };
-    }
-    else {
-        distZipConfig = false;
-    }
-    let imageOptimizerConfig = imageOptimizer;
-    if (typeof imageOptimizer === 'boolean') {
-        if (imageOptimizerConfig === true) {
-            imageOptimizerConfig = {};
-        }
-    }
-    else if (typeof imageOptimizer !== 'object') {
-        imageOptimizerConfig = false;
-    }
-    return {
-        enableProxyCache,
-        proxyCacheTTL,
-        disableSSLValidation,
-        imageOptimizer: imageOptimizerConfig,
-        templateLess,
-        miHudLess,
-        outDir,
-        distZip: distZipConfig,
-        syncBackupsDir,
-        v7Features,
-        ...config,
-    };
-}
-function vitePPDev(options) {
-    const { templateName, templateLess, backendBaseURL, miHudLess, portalPageId, enableProxyCache, proxyCacheTTL, disableSSLValidation, distZip, syncBackupsDir, v7Features, } = options || {};
-    // Avoid server caching for index.html file when first loading
-    let isFirstRequest = true;
-    process.cwd();
-    return {
-        name: 'vite-pp-dev',
-        apply: 'serve',
-        config: (config) => {
-            config.clientInjectionPlugin = { backendBaseURL, portalPageId, templateLess, v7Features };
-            if (v7Features) {
-                config.base = `/pl/${templateName}`;
-            }
-            if (config.root) {
-                config.root;
-            }
-            return config;
-        },
-        transformIndexHtml: async (html, ctx) => {
-            const result = { html, tags: [] };
-            if (isFirstRequest) {
-                isFirstRequest = false;
-                result.tags.push({
-                    tag: 'script',
-                    injectTo: 'body',
-                    children: `${Math.random()}`,
-                });
-            }
-            return result;
-        },
-        configureServer: (server) => {
-            let base = server.config.base;
-            if (!base.endsWith('/')) {
-                base += '/';
-            }
-            const baseWithoutTrailingSlash = base.substring(0, base.lastIndexOf('/'));
-            server.middlewares.use(initPPRedirect(base, templateName));
-            if (backendBaseURL) {
-                const baseUrlHost = new URL(backendBaseURL).host;
-                const mi = new MiAPI(backendBaseURL, {
-                    headers: {
-                        host: baseUrlHost,
-                        referer: backendBaseURL,
-                        origin: backendBaseURL.replace(/^(https?:\/\/)([^/]+)(\/.*)?$/i, '$1$2'),
-                    },
-                    portalPageId,
-                    templateLess,
-                    disableSSLValidation,
-                    v7Features,
-                });
-                if (enableProxyCache) {
-                    let ttl = +proxyCacheTTL;
-                    if (!ttl || Number.isNaN(ttl) || ttl < 0) {
-                        ttl = 10 * 60 * 1000; // 10 minutes
-                    }
-                    server.middlewares.use(initProxyCache({ devServer: server, ttl }));
-                }
-                server.middlewares.use(initProxy({
-                    devServer: server,
-                    baseURL: backendBaseURL,
-                    proxyIgnore: ['/@vite', '/@metricinsights', '/@', baseWithoutTrailingSlash],
-                    disableSSLValidation,
-                }));
-                const isIndexRegExp = new RegExp(`^((${base})|/)$`);
-                // Get portal page variables from the backend (also, redirect magic)
-                server.middlewares.use(initLoadPPData(isIndexRegExp, mi, options));
-                const distService = distZip !== false
-                    ? new DistService(templateName, Object.assign({ backupDir: syncBackupsDir }, typeof distZip === 'object'
-                        ? { distZipFolder: distZip.outDir, distZipFilename: distZip.outFileName }
-                        : undefined))
-                    : undefined;
-                new ClientService(server, { distService, miAPI: mi });
-                return () => {
-                    server.middlewares.use(initRewriteResponse((url) => {
-                        return url.endsWith('index.html');
-                    }, (response, req) => {
-                        return Buffer.from(urlReplacer(baseUrlHost, req.headers.host ?? '', mi.buildPage(response, miHudLess)));
-                    }));
-                };
-            }
-        },
-    };
-}
-
-exports.MiAPI = MiAPI;
-exports.colors = colors;
-exports.createLogger = createLogger;
-exports.cutUrlParams = cutUrlParams;
-exports.initLoadPPData = initLoadPPData;
-exports.initPPRedirect = initPPRedirect;
-exports.initProxy = initProxy;
-exports.initProxyCache = initProxyCache;
-exports.initRewriteResponse = initRewriteResponse;
-exports.normalizeVitePPDevConfig = normalizeVitePPDevConfig;
-exports.urlReplacer = urlReplacer;
-exports.vitePPDev = vitePPDev;
-//# sourceMappingURL=plugin-DZS4Taov.js.map