@calvin_von/proxy-plugin-inject/configure.js

A dalao-proxy plugin for inject scripts into html

const fs = require('fs');
// presets
const PresetConsole = require('./presets/mobile-console');
const CdpDebugger = require('./presets/cdp-debugger');

/**
 * Config field
 * @example
 *  "inject": {
 *      rules: [
 *          {
 *              test: 'index\.html$',
 *              serves: {
 *                  'inject-file.js': './libs/injected-file.js',
 *                  'inject-style.css': './libs/inject-style.css'
 *              },
 *              proxy: {
 *                  '/rule': {
 *                      'target': 'http://some-address/path',
 *                      'pathRewrite': {
                            '/rule': ''
 *                      }
 *                  }
 *              },
 *              template: '<script>alert('something')</script>',
 *              templateSrc: './inject-script-to-html.js',
 *              insert: 'body'
 *          }
 *      ],
 *      presets: {
 *          mobileConsole: false,
 *          cdp: false,
 *      }
 *  }
 */
const defaultOptions = {
    rules: [],
    presets: {
        mobileConsole: false,
        cdpDebugger: false
    }
};

module.exports = {
    setting() {
        return {
            optionsField: 'inject'
        };
    },

    parser(rawOptions) {
        if (rawOptions && typeof rawOptions === 'object') {
            const presets = {
                ...defaultOptions.presets,
                ...(rawOptions.presets || {})
            };
            return {
                ...defaultOptions,
                ...{
                    rules: parseRules(rawOptions.rules || [], presets),
                    presets
                }
            }
        }
        else {
            return {
                rules: parseRules([], defaultOptions.presets),
                presets: defaultOptions.presets
            };
        }
    }
};


function parseRules(rawRules, presets) {
    const rules = [];
    if (presets.mobileConsole) {
        if (typeof(presets.mobileConsole) === 'object') {
            Object.assign(PresetConsole.rules, presets.mobileConsole);
        }
        rules.push(PresetConsole.rules);
    }
    if (presets.cdpDebugger) {
        if (typeof(presets.cdpDebugger) === 'object') {
            Object.assign(CdpDebugger.rules, presets.cdpDebugger);
        }
        rules.push(CdpDebugger.rules);
    }

    rules.push(
        ...rawRules
            .filter((rule, index) => {
                if (!rule.test) {
                    console.warn('[Plugin inject]: inject.rules.' + index + '.test should not be empty');
                    return false;
                }
                if (!rule.template && !lookUpTemplateFile(rule.templateSrc)) {
                    console.warn('[Plugin inject]: inject.rules.' + index + ' no template or template file found');
                    return false;
                }

                if (!/^(head|body)$/.test(rule.insert)) {
                    if (!rule.insert) {
                        rule.insert = 'body';
                    }
                    else {
                        console.warn('[Plugin inject]: inject.rules.' + index + '.insert should be `body` or `head`');
                        return false;
                    }
                }

                return true;

                function lookUpTemplateFile(src) {
                    return fs.existsSync(src);
                }
            })
    );

    return rules;
}