@metricinsights/pp-dev 0.9.0 → 0.10.1

package/dist/esm/plugin-BeHiwpzF.js

@@ -1,1277 +0,0 @@
-import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
-import { fileURLToPath, URL as URL$1 } from 'url';
-import { createLogger as createLogger$1 } from 'vite';
-import { createColors } from 'picocolors';
-import axios from 'axios';
-import { JSDOM } from 'jsdom';
-import { Agent } from 'https';
-import * as memoryCache from 'memory-cache';
-import * as path from 'path';
-import { promises } from 'fs';
-import * as crypto from 'crypto';
-import * as process$1 from 'process';
-import * as child_process from 'child_process';
-import * as console from 'console';
-import { deflateSync, brotliDecompressSync, unzipSync, inflateSync, brotliCompressSync, gzipSync } from 'zlib';
-
-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 = createLogger$1(level);
-        storage.set(name, logger);
-        return logger;
-    }
-    const logger = createLogger$1(level);
-    storage.set(name, logger);
-    return logger;
-};
-
-const colors = 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 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 = 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 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(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.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.dirname((typeof __filename !== 'undefined' && __filename) || fileURLToPath(import.meta.url));
-const pluginPath = path.resolve(DIRNAME, '..', '..');
-const node_modules_path = path.resolve(pluginPath, '..', '..');
-const metaDirName = '.pp-dev-meta';
-const metaDirPath = path.resolve(node_modules_path, metaDirName);
-const metaFilePath = path.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.resolve(process$1.cwd(), 'backups'), distZipFolder = path.resolve(process$1.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 promises.stat(metaDirPath);
-        }
-        catch {
-            await promises.mkdir(metaDirPath);
-        }
-        try {
-            await promises.stat(this.backupFolder);
-        }
-        catch {
-            await promises.mkdir(this.backupFolder);
-        }
-    }
-    async readMetaFile() {
-        await this.checkMeta();
-        return await promises
-            .readFile(metaFilePath, {
-            encoding: 'utf-8',
-        })
-            .catch(() => '{}');
-    }
-    async writeMetaFile(meta) {
-        await this.checkMeta();
-        return await 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.resolve(this.backupFolder, lastBackupName);
-        try {
-            await 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.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 promises.writeFile(path.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.spawn('node', [path.resolve(pluginPath, './bin/pp-dev.js'), 'build'], {
-                cwd: process$1.cwd(),
-                env: Object.assign({}, process$1.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.resolve(process$1.cwd(), this.distZipFolder, this.distZipFilename);
-            if (!(await promises.stat(assetFile))) {
-                throw new Error(`File ${assetFile} not found`);
-            }
-            return await promises.readFile(assetFile);
-        }
-        catch (e) {
-            console.log(e);
-            throw e;
-        }
-    }
-    async saveBackupAndBuild(backupFile) {
-        await this.saveBackup(backupFile);
-        return await this.buildNewAssets();
-    }
-}
-
-function decodeContent(content, contentEncoding) {
-    switch (contentEncoding) {
-        case 'gzip':
-            return unzipSync(content);
-        case 'br':
-            return brotliDecompressSync(content);
-        case 'deflate':
-            return deflateSync(content);
-        default:
-            return content;
-    }
-}
-function encodeContent(content, contentEncoding) {
-    switch (contentEncoding) {
-        case 'gzip':
-            return gzipSync(content);
-        case 'br':
-            return brotliCompressSync(content);
-        case 'deflate':
-            return 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$1(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)));
-                    }));
-                };
-            }
-        },
-    };
-}
-
-export { MiAPI as M, colors as a, initProxyCache as b, createLogger as c, initProxy as d, initLoadPPData as e, initRewriteResponse as f, cutUrlParams as g, initPPRedirect as i, normalizeVitePPDevConfig as n, urlReplacer as u, vitePPDev as v };
-//# sourceMappingURL=plugin-BeHiwpzF.js.map