@steambrew/client/build/webpack.js

A support library for creating plugins with Millennium.

import Logger from './logger';
const logger = new Logger('Webpack');
export let modules = new Map();
function initModuleCache() {
    const startTime = performance.now();
    logger.group('Webpack Module Init');
    // Webpack 5, currently on beta
    // Generate a fake module ID
    const id = Symbol('@steambrew/client');
    let webpackRequire;
    // Insert our module in a new chunk.
    // The module will then be called with webpack's internal require function as its first argument
    window.webpackChunksteamui.push([
        [id],
        {},
        (r) => {
            webpackRequire = r;
        },
    ]);
    logger.log('Initializing all modules. Errors here likely do not matter, as they are usually just failing module side effects.');
    // Loop over every module ID
    for (let id of Object.keys(webpackRequire.m)) {
        try {
            const module = webpackRequire(id);
            if (module) {
                modules.set(id, module);
            }
        }
        catch (e) {
            logger.debug('Ignoring require error for module', id, e);
        }
    }
    logger.groupEnd(`Modules initialized in ${performance.now() - startTime}ms...`);
}
initModuleCache();
export const findModule = (filter) => {
    for (const m of modules.values()) {
        if (m.default && filter(m.default))
            return m.default;
        if (filter(m))
            return m;
    }
};
export const findModuleDetailsByExport = (filter, minExports) => {
    for (const [id, m] of modules) {
        if (!m)
            continue;
        for (const mod of [m.default, m]) {
            if (typeof mod !== 'object')
                continue;
            if (minExports && Object.keys(mod).length < minExports)
                continue;
            for (let exportName in mod) {
                if (mod?.[exportName]) {
                    try {
                        const filterRes = filter(mod[exportName], exportName);
                        if (filterRes) {
                            return [mod, mod[exportName], exportName, id];
                        }
                        else {
                            continue;
                        }
                    }
                    catch { }
                }
            }
        }
    }
    return [undefined, undefined, undefined, undefined];
};
export const findModuleByExport = (filter, minExports) => {
    return findModuleDetailsByExport(filter, minExports)?.[0];
};
export const findModuleExport = (filter, minExports) => {
    return findModuleDetailsByExport(filter, minExports)?.[1];
};
/**
 * @deprecated use findModuleExport instead
 */
export const findModuleChild = (filter) => {
    for (const m of modules.values()) {
        for (const mod of [m.default, m]) {
            const filterRes = filter(mod);
            if (filterRes) {
                return filterRes;
            }
            else {
                continue;
            }
        }
    }
};
/**
 * @deprecated use createModuleMapping instead
 */
export const findAllModules = (filter) => {
    const out = [];
    for (const m of modules.values()) {
        if (m.default && filter(m.default))
            out.push(m.default);
        if (filter(m))
            out.push(m);
    }
    return out;
};
export const createModuleMapping = (filter) => {
    const mapping = new Map();
    for (const [id, m] of modules) {
        if (m.default && filter(m.default))
            mapping.set(id, m.default);
        if (filter(m))
            mapping.set(id, m);
    }
    return mapping;
};
export const CommonUIModule = findModule((m) => {
    if (typeof m !== 'object')
        return false;
    for (let prop in m) {
        if (m[prop]?.contextType?._currentValue && Object.keys(m).length > 60)
            return true;
    }
    return false;
});
export const ReactRouter = findModuleByExport((e) => e.computeRootMatch);