@farmfe/core/dist/plugin/index.js

Farm is a extremely fast web build tool written in Rust. Farm can start a project in milliseconds and perform HMR within 10ms, making it much faster than similar tools like webpack and vite.

import { isArray, isObject } from '../utils/index.js';
import { convertPlugin } from './js/index.js';
import { rustPluginResolver } from './rust/index.js';
import merge from '../utils/merge.js';
export * from './js/index.js';
export * from './rust/index.js';
export async function resolveFarmPlugins(config) {
    const plugins = config.plugins ?? [];
    if (!plugins.length) {
        return {
            rustPlugins: [],
            jsPlugins: []
        };
    }
    const rustPlugins = [];
    const jsPlugins = [];
    for (const plugin of plugins) {
        if (!plugin) {
            continue;
        }
        if (typeof plugin === 'string' ||
            (isArray(plugin) && typeof plugin[0] === 'string')) {
            rustPlugins.push(await rustPluginResolver(plugin, config.root ?? process.cwd()));
        }
        else if (isObject(plugin)) {
            convertPlugin(plugin);
            jsPlugins.push(plugin);
        }
        else if (isArray(plugin)) {
            for (const pluginNestItem of plugin) {
                convertPlugin(pluginNestItem);
                jsPlugins.push(pluginNestItem);
            }
        }
        else {
            throw new Error(`plugin ${plugin} is not supported, Please pass the correct plugin type`);
        }
    }
    return {
        rustPlugins,
        jsPlugins
    };
}
// resolve promise plugins
export async function resolveAsyncPlugins(arr) {
    return arr.reduce(async (acc, current) => {
        const flattenedAcc = await acc;
        if (current instanceof Promise) {
            const resolvedElement = await current;
            return flattenedAcc.concat(resolvedElement);
        }
        else if (Array.isArray(current)) {
            const flattenedArray = await resolveAsyncPlugins(current);
            return flattenedAcc.concat(flattenedArray);
        }
        else {
            return flattenedAcc.concat(current);
        }
    }, Promise.resolve([]));
}
export async function resolveConfigHook(config, plugins) {
    let conf = config;
    const uniqueVitePlugins = new Map();
    for (const p of plugins) {
        const pluginName = p.name;
        if (!uniqueVitePlugins.has(pluginName)) {
            uniqueVitePlugins.set(pluginName, p);
        }
    }
    for (const p of uniqueVitePlugins.values()) {
        if (p.config) {
            const res = await p.config(conf);
            if (res) {
                conf = merge(conf, res);
            }
        }
    }
    return conf;
}
export async function resolveConfigResolvedHook(config, plugins) {
    for (const p of plugins) {
        if (p.configResolved) {
            await p.configResolved(config);
        }
    }
}
export function getSortedPlugins(plugins) {
    // TODO The priority needs to be redefined.
    const DEFAULT_PRIORITY = 100;
    const sortedPlugins = plugins
        .filter((plugin) => typeof plugin === 'object' && typeof plugin.priority === 'number')
        .sort((a, b) => b.priority - a.priority);
    const prePlugins = sortedPlugins.filter((plugin) => plugin?.priority > DEFAULT_PRIORITY);
    const postPlugins = sortedPlugins.filter((plugin) => plugin?.priority < DEFAULT_PRIORITY);
    const normalPlugins = plugins.filter((plugin) => (typeof plugin === 'object' && typeof plugin.priority !== 'number') ||
        plugin?.priority === DEFAULT_PRIORITY);
    return [...prePlugins, ...normalPlugins, ...postPlugins];
}
export function getSortedPluginHooks(plugins, hookName) {
    return plugins.map((p) => p[hookName]).filter(Boolean);
}
//# sourceMappingURL=index.js.map