@metricinsights/pp-dev 0.3.0 → 0.3.2

package/dist/esm/plugin-ecb1c54a.js

@@ -0,0 +1,843 @@
+import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
+import { fileURLToPath, URL as URL$1 } from 'url';
+import axios from 'axios';
+import { JSDOM } from 'jsdom';
+import * as memoryCache from 'memory-cache';
+import * as path from 'path';
+import { promises } from 'fs';
+import * as crypto from 'crypto';
+import * as process 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 || 302;
+    res.end();
+};
+function cutUrlParams(url) {
+    const urlParts = url.split('?');
+    return urlParts[0];
+}
+
+const hostOriginRegExp = /^(https?:\/\/)([^/]+)(\/.*)?$/i;
+const PROXY_HEADER = 'X-PP-Proxy';
+function initProxy(opts) {
+    const { rewritePath = /^\/(?!pt).*/i, baseURL = '', devServer } = 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');
+    return createProxyMiddleware((pathname) => {
+        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;
+        })) {
+            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;
+    }, {
+        /**
+         * IMPORTANT: avoid res.end being called automatically
+         **/
+        selfHandleResponse: true,
+        target: baseURL,
+        changeOrigin: true,
+        autoRewrite: true,
+        logLevel: 'silent',
+        headers: {
+            host,
+            origin,
+        },
+        onProxyReq(proxyReq, req, res) {
+            const host = req.headers.host;
+            const referer = proxyReq.getHeader('referer');
+            devServer.config.logger.info(`Proxies request: ${req.method} ${req.url} -> ${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;
+        },
+        onProxyRes: 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')) {
+                        response +=
+                            '<script>' +
+                                'const params = new URLSearchParams(window.location.search);' +
+                                "if (params.has('proxyRedirect')) {" +
+                                " setTimeout(() => { window.location = params.get('proxyRedirect'); }, 50);" +
+                                '}' +
+                                '</script>';
+                    }
+                }
+                catch {
+                    //
+                }
+                const reqHost = req.headers.host ?? '';
+                // manipulate response and return the result
+                return urlPathReplacer('/auth/saml/login', '/login', urlReplacer(host, reqHost, response));
+            }
+        }),
+    });
+}
+
+class BaseAPI {
+    axios;
+    constructor(axios) {
+        this.axios = axios;
+    }
+}
+
+class AssetsAPI extends BaseAPI {
+    // Import for CJS and ESM
+    formdataModulePromise = import('formdata-node');
+    constructor(axios) {
+        super(axios);
+    }
+    async downloadPageAssets(portalPageId, headers) {
+        return this.axios
+            .get(`/admin/page/downloadassets/id/${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 = `/admin/page/uploadassets/id/${portalPageId}`;
+        return this.axios
+            .post(`/admin/page/uploadassets/id/${portalPageId}`, 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(`/admin/pagetemplate/downloadassets/id/${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 = `/admin/pagetemplate/uploadassets/id/${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 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 MiAPI {
+    #headers;
+    #axios;
+    #pageTemplate = null;
+    #pageTitle;
+    #pageVars;
+    #templateLoaded;
+    #templateLoadedResolve;
+    portalPageId;
+    templateLess;
+    assetsApi;
+    pageApi;
+    constructor(baseURL, opts) {
+        const { headers = {}, portalPageId, templateLess = true } = opts || {};
+        this.#headers = headers;
+        this.#pageVars = [];
+        this.#pageTitle = '';
+        this.#templateLoaded = new Promise((resolve) => {
+            this.#templateLoadedResolve = resolve;
+        });
+        this.#axios = axios.create({ baseURL, headers });
+        this.portalPageId = portalPageId;
+        this.templateLess = templateLess;
+        this.assetsApi = new AssetsAPI(this.#axios);
+        this.pageApi = new PageAPI(this.#axios);
+    }
+    async isTemplateLoaded() {
+        return this.#templateLoaded;
+    }
+    #clearHeaders(headers) {
+        const obj = Object.assign({}, headers, { host: undefined });
+        Object.keys(obj).forEach((key) => obj[key] === undefined && delete obj[key]);
+        this.#headers = obj;
+        return obj;
+    }
+    updateHeaders(headers) {
+        this.#clearHeaders(headers);
+    }
+    /**
+     * Get page template
+     * @param headers
+     */
+    async getPageTemplate(headers) {
+        if (this.#pageTemplate) {
+            return Promise.resolve(this.#pageTemplate);
+        }
+        if (typeof this.templateLess === 'undefined') {
+            this.templateLess = false;
+        }
+        const pageList = await this.pageApi.getAll(this.#clearHeaders(headers));
+        let page = pageList.find((p) => p.name === '[DEV PAGE. DO NOT DELETE]');
+        if (!page) {
+            page = await this.pageApi.create({
+                enabled: 'Y',
+                name: '[DEV PAGE. DO NOT DELETE]',
+                internal_name: 'dev-page-template',
+                visible_in_homepage: 'Y',
+            }, this.#clearHeaders(headers));
+        }
+        return await this.pageApi
+            .getPageContent(page.internal_name, this.#clearHeaders(headers))
+            .then((response) => {
+            this.#pageTemplate = response;
+            return response;
+        })
+            .finally(() => {
+            this.#templateLoadedResolve(true);
+        });
+    }
+    /**
+     * 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) => {
+            if (reason.response?.status === 404) {
+                throw new Error(`Portal Page with id "${pageId}" not found 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);
+                }
+                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 (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 (pageInfo.template) {
+                    return await this.assetsApi.uploadTemplateAssets(pageInfo.template, assets, this.#headers);
+                }
+            }
+        }
+    }
+}
+
+class ClientService {
+    server;
+    opts;
+    eventMap;
+    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.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;
+            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,
+                    });
+                }
+                else {
+                    this.server.ws.send('template:sync:response', { error: 'Failed to update assets' });
+                }
+            }
+            else {
+                this.server.ws.send('template:sync:response', { error: 'Failed to build new assets' });
+                return;
+            }
+        }
+        else {
+            this.server.ws.send('template:sync:response', { error: '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;
+    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 && devServer.config) {
+                devServer.config.logger.info(`Proxies request: ${req.method} ${url} -> 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)) {
+                    devServer.config.logger?.info(`[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;
+    constructor(pageName, syncOptions) {
+        const { backupFolder = path.resolve(process.cwd(), 'backups'), 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.pageName = pageName;
+        this.syncMeta();
+    }
+    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);
+    }
+    async buildNewAssets() {
+        const buildCommand = new Promise(function (resolve, reject) {
+            let data = '';
+            // Colorized log output with message about build start
+            console.log('\x1b[36m%s\x1b[0m', '[DistService] Build started');
+            const proc = child_process.spawn('node', [path.resolve(pluginPath, './bin/pp-dev.js'), 'build'], {
+                cwd: process.cwd(),
+                env: process.env,
+                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
+                console.log('\x1b[36m%s\x1b[0m', '[DistService] Build finished');
+            });
+            const assetFile = path.resolve(process.cwd(), `./dist-zip/${this.pageName}.zip`);
+            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 (req, res, next) => {
+        if (predicate(req.url ?? '', req, res)) {
+            const end = res.end;
+            const buffers = [];
+            res.write = function (body) {
+                buffers.push(body);
+                return true;
+            };
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            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);
+                end.call(this, encodeContent(rewrite(content, req, res), contentEncoding), encoding, cb);
+            };
+        }
+        next();
+    };
+}
+
+function initPPRedirect(base, templateName) {
+    base = base.startsWith('/') ? base : `/${base}`;
+    base = base.endsWith('/') ? base : `${base}/`;
+    const baseWithoutTrailingSlash = base.endsWith('/') ? base.slice(0, -1) : base;
+    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}`);
+        }
+        // Redirect from `/` and `/pt/${templateName}` and `${base}` (without a training slash) to portal page address
+        if (findPaths.includes(pathname)) {
+            const redirectUrl = `${base}${search}`;
+            return redirect(res, redirectUrl, 302);
+        }
+        next();
+    };
+}
+
+function initLoadPPData(applyUrlRegExp, mi, opts) {
+    const { templateLess = false, miHudLess = false, portalPageId } = opts;
+    return (req, res, next) => {
+        const isNeedTemplateLoad = !(templateLess && miHudLess);
+        const isApplyRequest = applyUrlRegExp.test(cutUrlParams(req.url ?? ''));
+        if (isNeedTemplateLoad && isApplyRequest) {
+            const headers = (req.headers ?? {});
+            const loadPageData = !templateLess && typeof portalPageId !== 'undefined'
+                ? mi.getPageVariables(portalPageId, headers)
+                : mi.getPageTemplate(headers);
+            loadPageData
+                .then(() => {
+                next();
+            })
+                .catch((reason) => {
+                if (reason.response) {
+                    return redirect(res, `/home?proxyRedirect=${encodeURIComponent('/')}`, 302);
+                }
+                next(reason);
+            });
+        }
+        else {
+            next();
+        }
+    };
+}
+
+function vitePPDev(options) {
+    const { templateName, templateLess = false, backendBaseURL, miHudLess = false, portalPageId, enableProxyCache = true, proxyCacheTTL = 10 * 60 * 1000, } = options || {};
+    // Avoid server caching for index.html file when first loading
+    let isFirstRequest = true;
+    return {
+        name: 'vite-pp-dev',
+        apply: 'serve',
+        config: (config) => {
+            config.clientInjectionPlugin = { backendBaseURL, portalPageId, templateLess };
+            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,
+                });
+                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],
+                }));
+                const isIndexRegExp = new RegExp(`^((${base})|/)$`);
+                // Get portal page variables from the backend (also, redirect magic)
+                server.middlewares.use(initLoadPPData(isIndexRegExp, mi, options));
+                server.middlewares.use(initRewriteResponse((url) => {
+                    return isIndexRegExp.test(cutUrlParams(url));
+                }, (response, req) => {
+                    return Buffer.from(urlReplacer(baseUrlHost, req.headers.host ?? '', mi.buildPage(response, miHudLess)));
+                }));
+                const distService = new DistService(templateName);
+                new ClientService(server, { distService, miAPI: mi });
+            }
+        },
+    };
+}
+
+export { MiAPI as M, initProxyCache as a, initProxy as b, initLoadPPData as c, initRewriteResponse as d, cutUrlParams as e, initPPRedirect as i, urlReplacer as u, vitePPDev as v };
+//# sourceMappingURL=plugin-ecb1c54a.js.map