@lynx-js/qrcode-rsbuild-plugin/dist/index.js

A rsbuild plugin for printing QRCode in terminal

import { registerConsoleShortcuts } from "./shortcuts.js";
function pluginQRCode(options) {
    const defaultPluginOptions = {
        schema: (url)=>({
                http: url
            }),
        fullscreen: false
    };
    const { schema, fullscreen } = Object.assign({}, defaultPluginOptions, options);
    const effectiveSchema = fullscreen ? withFullscreenSchema(schema) : schema;
    return {
        name: 'lynx:rsbuild:qrcode',
        pre: [
            'lynx:rsbuild:api'
        ],
        setup (api) {
            if (fullscreen) api.modifyRsbuildConfig({
                order: 'post',
                handler: (config, { mergeRsbuildConfig })=>{
                    const prev = config.server?.printUrls;
                    if ('function' != typeof prev) return;
                    return mergeRsbuildConfig(config, {
                        server: {
                            printUrls: wrapPrintUrlsWithFullscreen(prev)
                        }
                    });
                }
            });
            let unregisterPreviewShortcuts;
            api.onExit(()=>{
                unregisterPreviewShortcuts?.();
                unregisterPreviewShortcuts = void 0;
            });
            api.onAfterStartPreviewServer(async ({ environments, routes, port })=>{
                unregisterPreviewShortcuts?.();
                unregisterPreviewShortcuts = await main(getEntriesFromRoutes(routes, environments), port);
            });
            api.onAfterStartDevServer(async ({ environments, routes, port })=>{
                const entries = getEntriesFromRoutes(routes, environments);
                if (0 === entries.length) return;
                const unregister = await registerConsoleShortcuts({
                    entries,
                    api,
                    port,
                    schema: effectiveSchema
                });
                if (unregister) api.onCloseDevServer(unregister);
            });
            async function main(entries, port) {
                if (0 === entries.length) return;
                const unregister = await registerConsoleShortcuts({
                    entries,
                    api,
                    port,
                    schema: effectiveSchema
                });
                return unregister;
            }
        }
    };
}
function getEntriesFromRoutes(routes, environments) {
    const entries = new Set(Object.keys(environments['lynx']?.entry ?? {}));
    return [
        ...new Set(routes.map((route)=>route.entryName).filter((entryName)=>entries.has(entryName)))
    ];
}
function wrapPrintUrlsWithFullscreen(prev) {
    return (params)=>{
        const urls = prev(params) ?? [];
        const out = [];
        for (const entry of urls){
            out.push(entry);
            if ('string' != typeof entry && 'Lynx' === entry.label) out.push({
                label: '∟ Fullscreen',
                url: appendFullscreenParam(entry.url)
            });
        }
        return out;
    };
}
function withFullscreenSchema(schemaFn) {
    return (rawUrl)=>{
        const result = schemaFn(rawUrl);
        const map = 'string' == typeof result ? {
            default: result
        } : {
            ...result
        };
        const firstUrl = Object.values(map)[0];
        if (void 0 === firstUrl) return map;
        return {
            ...map,
            fullscreen: appendFullscreenParam(firstUrl)
        };
    };
}
function appendFullscreenParam(rawUrl) {
    try {
        const url = new URL(rawUrl);
        url.searchParams.set('fullscreen', 'true');
        return url.toString();
    } catch  {
        const separator = rawUrl.includes('?') ? '&' : '?';
        return `${rawUrl}${separator}fullscreen=true`;
    }
}
export { pluginQRCode, withFullscreenSchema, wrapPrintUrlsWithFullscreen };