05_week/solution/plugins/loadExternalUrlsPlugin.js - master - aurora/test

05_week/solution/plugins/loadExternalUrlsPlugin.js
122 строки4 KB
auroraptor
WIP
14 июл 2024, 17:55
14 июл 2024, 17:550e476ff
const fs = require('fs');
const path = require('path');
const http = require('http');
const https = require('https');

const PLUGIN_NAME = 'LoadExternalUrlsPlugin';

class LoadExternalUrlsPlugin {
    constructor(options) {
        this.urls = options.urls;
        this.externalResources = [];
    }

    downloadResource(url, outputPath) {
        return new Promise((resolve, reject) => {
            const protocol = url.startsWith('https') ? https : http;

            protocol.get(url, (response) => {
                const data = [];

                response.on('data', (chunk) => {
                    data.push(chunk);
                });

                response.on('end', () => {
                    const buffer = Buffer.concat(data);
                    const outputDir = path.dirname(outputPath);

                    if (!fs.existsSync(outputDir)) {
                        fs.mkdirSync(outputDir, { recursive: true });
                    }

                    fs.writeFileSync(outputPath, buffer);
                    console.log(`Downloaded: ${url} to ${outputPath}`);
                    resolve();
                });
            }).on('error', (err) => {
                console.error(`Failed to download: ${url}`, err);
                reject(err);
            });
        });
    }

    async processUrlsFile() {
        const promises = Object.entries(this.urls).map(([fileName, url]) => {
            const outputPath = path.resolve(__dirname, '..', 'src', 'assets', fileName);
            console.log(`Processing URL from urls.js: ${url}`);
            return this.downloadResource(url, outputPath);
        });

        await Promise.all(promises);
    }

    async replaceExternalUrlsInSourceFiles() {
        const sourceFiles = ['./src/index.js'];

        for (const filePath of sourceFiles) {
            let content = fs.readFileSync(filePath, 'utf-8');
            this.externalResources.forEach(url => {
                const fileName = path.basename(url);
                content = content.replace(new RegExp(url, 'g'), `./assets/${fileName}`);
            });
            fs.writeFileSync(filePath, content, 'utf-8');
        }
    }

    async replaceExternalUrlsInHtmlFiles() {
        const htmlFiles = ['./src/index.html'];

        for (const filePath of htmlFiles) {
            let content = fs.readFileSync(filePath, 'utf-8');

            const imgRegex = /<img\s+[^>]*src=["']([^"']+)["'][^>]*>/g;
            content = content.replace(imgRegex, (match, p1) => {
                const fileName = path.basename(p1);
                return match.replace(p1, `./assets/${fileName}`);
            });

            Object.entries(this.urls).forEach(([fileName, url]) => {
                content = content.replace(new RegExp(url, 'g'), `./assets/${fileName}`);
            });

            fs.writeFileSync(filePath, content, 'utf-8');
        }
    }

    apply(compiler) {
        compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, async (params, callback) => {
            console.log('Processing external imports');

            const externalResources = [];
            const sourceFiles = ['./src/index.js'];

            sourceFiles.forEach(file => {
                let content = fs.readFileSync(file, 'utf-8');
                const regex = /import .* from ['"](http.*)['"]/g;
                let match;
                while ((match = regex.exec(content)) !== null) {
                    externalResources.push(match[1]);
                }
            });

            this.externalResources = externalResources;

            const promises = this.externalResources.map(url => {
                const fileName = path.basename(url);
                const outputPath = path.resolve(__dirname, '..', 'src', 'assets', fileName);
                console.log(`Downloading external resource: ${url}`);
                return this.downloadResource(url, outputPath);
            });

            await this.processUrlsFile();
            await Promise.all(promises);
            await this.replaceExternalUrlsInSourceFiles();
            await this.replaceExternalUrlsInHtmlFiles();

            callback();
        });
    }
}

module.exports = LoadExternalUrlsPlugin;