@bleedingdev/modern-js-plugin 3.2.0-ultramodern.0

package/dist/esm-node/cli/run/create.mjs

@@ -0,0 +1,159 @@
+import "node:module";
+import { createDebugger, logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+import { loadEnv } from "@rsbuild/core";
+import { createPluginManager } from "../../manager.mjs";
+import { initPluginAPI } from "../api.mjs";
+import { createContext, initAppContext } from "../context.mjs";
+import { createLoadedConfig } from "./config/createLoadedConfig.mjs";
+import { createResolveConfig } from "./config/createResolvedConfig.mjs";
+import { checkIsDuplicationPlugin } from "./utils/checkIsDuplicationPlugin.mjs";
+import { initCommandsMap, setProgramVersion } from "./utils/commander.mjs";
+import { createFileWatcher } from "./utils/createFileWatcher.mjs";
+import { initAppDir } from "./utils/initAppDir.mjs";
+const debug = createDebugger('plugin');
+const createCli = ()=>{
+    let initOptions;
+    const pluginManager = createPluginManager();
+    const existListenerMap = new Map();
+    function createExistListener(event, context) {
+        return async function(err) {
+            await context.hooks.onBeforeExit.call();
+            let hasError = false;
+            if (err instanceof Error) {
+                logger.error(err.stack);
+                hasError = true;
+            } else if (err && ('unhandledRejection' === event || 'uncaughtException' === event)) {
+                console.trace('Unknown Error', err);
+                hasError = true;
+            }
+            process.nextTick(()=>{
+                process.exit(hasError ? 1 : 0);
+            });
+        };
+    }
+    async function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { metaName = 'modern-js', configFile, config, command, version, internalPlugins, handleSetupResult } = options;
+        const appDirectory = await initAppDir(options?.cwd);
+        initCommandsMap();
+        setProgramVersion(version);
+        const envName = 'modern-js' === metaName ? 'MODERN' : metaName;
+        loadEnv({
+            cwd: appDirectory,
+            mode: process.env[`${envName.toUpperCase()}_ENV`] || process.env.NODE_ENV,
+            prefixes: [
+                `${envName.toUpperCase()}_`
+            ]
+        });
+        const loaded = await createLoadedConfig(appDirectory, configFile, config);
+        const allPlugins = [
+            ...internalPlugins || [],
+            ...loaded.config.plugins || []
+        ];
+        checkIsDuplicationPlugin(allPlugins.map((plugin)=>plugin.name));
+        pluginManager.addPlugins(allPlugins);
+        const plugins = await pluginManager.getPlugins();
+        debug('CLI Plugins:', plugins.map((p)=>p.name));
+        const context = await createContext({
+            appContext: initAppContext({
+                packageName: loaded.packageName,
+                configFile: loaded.configFile,
+                command: command,
+                appDirectory,
+                plugins,
+                metaName
+            }),
+            config: loaded.config,
+            normalizedConfig: {}
+        });
+        const pluginAPI = initPluginAPI({
+            context,
+            pluginManager
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = await plugin.setup?.(pluginAPI);
+            if (handleSetupResult) await handleSetupResult(setupResult, pluginAPI);
+        }
+        [
+            'SIGINT',
+            'SIGTERM',
+            'unhandledRejection',
+            'uncaughtException'
+        ].forEach((event)=>{
+            if (existListenerMap.get(event)) process.off(event, existListenerMap.get(event));
+            const existListener = createExistListener(event, context);
+            existListenerMap.set(event, existListener);
+            process.on(event, existListener);
+        });
+        const extraConfigs = await context.hooks.config.call();
+        const normalizedConfig = await createResolveConfig(loaded, extraConfigs);
+        const resolved = await context.hooks.modifyResolvedConfig.call(normalizedConfig);
+        context.normalizedConfig = resolved || normalizedConfig;
+        await pluginAPI.updateAppContext(context);
+        await context.hooks.onPrepare.call();
+        await context.hooks?.onAfterPrepare?.call();
+        return {
+            appContext: context
+        };
+    }
+    async function run(options) {
+        const { appContext } = await init(options);
+        await appContext.hooks.addCommand.call({
+            program: program
+        });
+        await createFileWatcher(appContext);
+        program.parse(process.argv);
+        if (!program.commands?.length) logger.warn('No command found, please make sure you have registered plugins correctly.');
+    }
+    return {
+        init,
+        run,
+        getPrevInitOptions: ()=>initOptions
+    };
+};
+const createConfigOptions = async (options)=>{
+    const pluginManager = createPluginManager();
+    pluginManager.clear();
+    const { configFile, cwd, metaName = 'modern-js', command } = options;
+    const appDirectory = await initAppDir(cwd);
+    const loaded = await createLoadedConfig(appDirectory, configFile, options.config);
+    loaded.config = options.modifyModernConfig ? await options.modifyModernConfig(loaded.config || {}) : loaded.config;
+    pluginManager.addPlugins(loaded.config.plugins || []);
+    const plugins = await pluginManager.getPlugins();
+    const context = await createContext({
+        appContext: initAppContext({
+            packageName: loaded.packageName,
+            configFile: loaded.configFile,
+            appDirectory,
+            command,
+            plugins,
+            metaName
+        }),
+        config: loaded.config,
+        normalizedConfig: {}
+    });
+    const pluginAPI = initPluginAPI({
+        context,
+        pluginManager
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins)await plugin.setup?.(pluginAPI);
+    const extraConfigs = await context.hooks.config.call();
+    const normalizedConfig = await createResolveConfig(loaded, extraConfigs);
+    const resolved = await context.hooks.modifyResolvedConfig.call(normalizedConfig);
+    const finalConfig = resolved || normalizedConfig;
+    context.normalizedConfig = finalConfig;
+    await pluginAPI.updateAppContext(context);
+    return {
+        config: finalConfig,
+        getAppContext: ()=>pluginAPI.getAppContext()
+    };
+};
+const createStorybookOptions = (options)=>createConfigOptions({
+        ...options,
+        command: 'storybook'
+    });
+export { createCli, createConfigOptions, createStorybookOptions };

package/dist/esm-node/cli/run/index.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import { createCli } from "./create.mjs";
+const cli = createCli();
+export { createLoadedConfig } from "./config/createLoadedConfig.mjs";
+export { loadTypeScriptFile } from "./config/loadConfig.mjs";
+export { run } from "./run.mjs";
+export { initAppDir } from "./utils/initAppDir.mjs";
+export { cli, createCli };

package/dist/esm-node/cli/run/run.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+import { cli } from "./index.mjs";
+const run = async (options)=>{
+    const { initialLog, version, cwd, configFile, ...params } = options;
+    if (initialLog) logger.greet(`  ${initialLog}\n`);
+    const command = process.argv[2];
+    if (!process.env.NODE_ENV) if ([
+        'build',
+        'serve',
+        'deploy',
+        'analyze'
+    ].includes(command)) process.env.NODE_ENV = 'production';
+    else if ('test' === command) process.env.NODE_ENV = 'test';
+    else process.env.NODE_ENV = 'development';
+    await cli.run({
+        version,
+        cwd,
+        command,
+        configFile,
+        ...params
+    });
+};
+export { run };

package/dist/esm-node/cli/run/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/cli/run/utils/checkIsDuplicationPlugin.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+function checkIsDuplicationPlugin(plugins) {
+    const set = new Set();
+    const duplicationPlugins = [];
+    plugins.filter((plugin)=>'string' == typeof plugin).forEach((plugin)=>{
+        if (set.has(plugin)) duplicationPlugins.push(plugin);
+        else set.add(plugin);
+    });
+    if (duplicationPlugins.length > 0) logger.warn(`Duplicate registration plugins: ${duplicationPlugins.join(',')}.`);
+}
+export { checkIsDuplicationPlugin };

package/dist/esm-node/cli/run/utils/commander.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+import { program } from "@modern-js/utils";
+const setProgramVersion = (version = 'unknown')=>{
+    const name = process.argv[1];
+    program.name(name).usage('<command> [options]').version(version);
+};
+function initCommandsMap() {
+    if (!program.hasOwnProperty('commandsMap')) Object.defineProperty(program, 'commandsMap', {
+        get () {
+            const map = new Map();
+            for (const command of program.commands)map.set(command._name, command);
+            return map;
+        },
+        configurable: false
+    });
+}
+export { initCommandsMap, program, setProgramVersion };

package/dist/esm-node/cli/run/utils/createFileWatcher.mjs

@@ -0,0 +1,69 @@
+import "node:module";
+import { chokidar, createDebugger, isDevCommand } from "@modern-js/utils";
+import crypto_0 from "crypto";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_path from "path";
+const debug = createDebugger('watch-files');
+const hashMap = new Map();
+const md5 = (data)=>crypto_0.createHash('md5').update(data).digest('hex');
+const createFileWatcher = async (appContext)=>{
+    if (isDevCommand()) {
+        const { appDirectory } = appContext;
+        const extraFiles = await appContext.hooks.addWatchFiles.call();
+        const watched = extraFiles.filter((extra)=>Array.isArray(extra)).flat();
+        const privateWatched = extraFiles.filter((extra)=>!Array.isArray(extra) && extra.isPrivate).map((extra)=>extra.files).flat();
+        const isPrivate = (filename)=>privateWatched.some((ff)=>__rspack_external_path.resolve(appDirectory, filename).startsWith(ff));
+        debug("watched: %o", watched);
+        const watcher = chokidar.watch([
+            ...watched,
+            ...privateWatched
+        ], {
+            cwd: appDirectory,
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            ignored: [
+                '**/__test__/**',
+                '**/*.test.(js|jsx|ts|tsx)',
+                '**/*.spec.(js|jsx|ts|tsx)',
+                '**/*.stories.(js|jsx|ts|tsx)'
+            ]
+        });
+        watcher.on('change', (changed)=>{
+            const lastHash = hashMap.get(changed);
+            const currentHash = md5(__rspack_external_fs.readFileSync(__rspack_external_path.join(appDirectory, changed), 'utf8'));
+            if (currentHash !== lastHash) {
+                debug("file change: %s", changed);
+                hashMap.set(changed, currentHash);
+                appContext.hooks.onFileChanged.call({
+                    filename: changed,
+                    eventType: 'change',
+                    isPrivate: isPrivate(changed)
+                });
+            }
+        });
+        watcher.on('add', (changed)=>{
+            debug("add file: %s", changed);
+            const currentHash = md5(__rspack_external_fs.readFileSync(__rspack_external_path.join(appDirectory, changed), 'utf8'));
+            hashMap.set(changed, currentHash);
+            appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: 'add',
+                isPrivate: isPrivate(changed)
+            });
+        });
+        watcher.on('unlink', (changed)=>{
+            debug("remove file: %s", changed);
+            if (hashMap.has(changed)) hashMap.delete(changed);
+            appContext.hooks.onFileChanged.call({
+                filename: changed,
+                eventType: 'unlink',
+                isPrivate: isPrivate(changed)
+            });
+        });
+        watcher.on('error', (err)=>{
+            throw err;
+        });
+        return watcher;
+    }
+};
+export { createFileWatcher };

package/dist/esm-node/cli/run/utils/debug.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger('plugin');
+export { debug };

package/dist/esm-node/cli/run/utils/initAppDir.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+import { pkgUp } from "@modern-js/utils";
+import path from "path";
+const initAppDir = async (currentDir)=>{
+    const cwd = currentDir || process.cwd();
+    const pkg = await pkgUp({
+        cwd
+    });
+    if (!pkg) throw new Error(`no package.json found in current work dir: ${cwd}`);
+    return path.dirname(pkg);
+};
+export { initAppDir };

package/dist/esm-node/cli/run/utils/mergeConfig.mjs

@@ -0,0 +1,33 @@
+import "node:module";
+import { ensureArray, isOverriddenConfigKey } from "@modern-js/utils";
+import { isEqual, isFunction, mergeWith } from "@modern-js/utils/lodash";
+const mergeConfig = (configs)=>mergeWith({}, ...configs, (target, source, key)=>{
+        if (isOverriddenConfigKey(key)) return source ?? target;
+        if (Array.isArray(target) || Array.isArray(source)) {
+            if (void 0 === target) return source;
+            if (void 0 === source) return target;
+            const targetArray = ensureArray(target);
+            const sourceArray = ensureArray(source);
+            const allItems = [
+                ...targetArray,
+                ...sourceArray
+            ];
+            const seenNonFunc = [];
+            const result = [];
+            for (const item of allItems)if (isFunction(item)) result.push(item);
+            else if (!seenNonFunc.some((seen)=>isEqual(seen, item))) {
+                seenNonFunc.push(item);
+                result.push(item);
+            }
+            return result;
+        }
+        if (isFunction(target) || isFunction(source)) {
+            if (void 0 === source) return target;
+            if (void 0 === target) return source;
+            return [
+                target,
+                source
+            ];
+        }
+    });
+export { mergeConfig };

package/dist/esm-node/hooks.mjs

@@ -0,0 +1,121 @@
+import "node:module";
+function createAsyncInterruptHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        let interrupted = false;
+        let interruptResult;
+        const interrupt = (info)=>{
+            interrupted = true;
+            interruptResult = info;
+        };
+        for (const callback of callbacks){
+            if (interrupted) break;
+            const result = await callback(...params, interrupt);
+            if (void 0 !== result) params[0] = result;
+        }
+        return interrupted ? interruptResult : params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createSyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = (...params)=>{
+        for (const callback of callbacks){
+            const result = callback(...params);
+            if (void 0 !== result) params[0] = result;
+        }
+        return params[0];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createAsyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        for (const callback of callbacks){
+            const result = await callback(...params);
+            if (void 0 !== result) params[0] = result;
+        }
+        return params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createCollectAsyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        const results = [];
+        for (const callback of callbacks){
+            const result = await callback(...params);
+            if (void 0 !== result) results.push(result);
+        }
+        return results;
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createCollectSyncHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = (...params)=>{
+        const results = [];
+        for (const callback of callbacks){
+            const result = callback(...params);
+            if (void 0 !== result) results.push(result);
+        }
+        return results;
+    };
+    return {
+        tap,
+        call
+    };
+}
+function createAsyncPipelineHook() {
+    const callbacks = [];
+    const tap = (cb)=>{
+        callbacks.push(cb);
+    };
+    const call = async (...params)=>{
+        for (const callback of callbacks){
+            let runNext = false;
+            const next = (info)=>{
+                runNext = true;
+                if (info) params[0] = info;
+            };
+            const result = await callback(...params, next);
+            if (!runNext) {
+                params[0] = result;
+                break;
+            }
+        }
+        return params[0] || [];
+    };
+    return {
+        tap,
+        call
+    };
+}
+export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook };

package/dist/esm-node/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook } from "./hooks.mjs";
+export { createPluginManager } from "./manager.mjs";

package/dist/esm-node/manager.mjs

@@ -0,0 +1,102 @@
+import "node:module";
+const isFunction = (obj)=>'function' == typeof obj;
+function validatePlugin(plugin) {
+    const type = typeof plugin;
+    if ('object' !== type || null === plugin) throw new Error(`Expect CLI Plugin instance to be an object, but got ${type}.`);
+    if (!plugin.setup) return;
+    if (isFunction(plugin.setup)) return;
+    throw new Error(`Expect CLI Plugin plugin.setup to be a function, but got ${type}.`);
+}
+function createPluginManager() {
+    const plugins = new Map();
+    const dependencies = new Map();
+    const addDependency = (plugin, dependency, type)=>{
+        if (!dependencies.has(dependency)) dependencies.set(dependency, {
+            pre: new Map(),
+            post: new Map()
+        });
+        if ('pre' === type) dependencies.get(plugin).pre.set(dependency, {
+            name: dependency,
+            isUse: false
+        });
+        else if ('post' === type) dependencies.get(plugin).post.set(dependency, {
+            name: dependency
+        });
+        else if ('use' === type) {
+            if (!dependencies.get(plugin).post.has(dependency) && !dependencies.get(dependency).pre.has(plugin)) dependencies.get(plugin).pre.set(dependency, {
+                name: dependency,
+                isUse: true
+            });
+        }
+    };
+    const addPlugin = (newPlugin)=>{
+        if (!newPlugin) return;
+        validatePlugin(newPlugin);
+        const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
+        if (plugins.has(name)) return void console.warn(`Plugin ${name} already exists.`);
+        plugins.set(name, newPlugin);
+        dependencies.set(name, {
+            pre: new Map(),
+            post: new Map()
+        });
+        pre.forEach((dep)=>{
+            addDependency(name, dep, 'pre');
+        });
+        post.forEach((dep)=>{
+            addDependency(name, dep, 'post');
+        });
+        usePlugins.forEach((plugin)=>{
+            if (!plugins.has(plugin.name)) addPlugin(plugin);
+            addDependency(name, plugin.name, 'use');
+        });
+    };
+    const addPlugins = (newPlugins)=>{
+        for (const newPlugin of newPlugins)addPlugin(newPlugin);
+    };
+    const getPlugins = ()=>{
+        const visited = new Set();
+        const temp = new Set();
+        let result = [];
+        const visit = (name)=>{
+            if (temp.has(name)) throw new Error(`Circular dependency detected: ${name}`);
+            if (!visited.has(name) && plugins.get(name)) {
+                temp.add(name);
+                const { required = [] } = plugins.get(name);
+                required.forEach((dep)=>{
+                    if (!plugins.get(dep)) throw new Error(`${name} plugin required plugin ${dep}, but not found.`);
+                });
+                const { pre } = dependencies.get(name);
+                Array.from(pre.values()).filter((dep)=>!dep.isUse).forEach((dep)=>visit(dep.name));
+                Array.from(pre.values()).filter((dep)=>dep.isUse).forEach((dep)=>visit(dep.name));
+                temp.delete(name);
+                visited.add(name);
+                result.push(plugins.get(name));
+            }
+        };
+        plugins.forEach((_, name)=>{
+            const { post } = dependencies.get(name);
+            post.forEach((dep)=>{
+                if (!dependencies.get(dep.name).pre.has(name)) dependencies.get(dep.name).pre.set(name, {
+                    name,
+                    isUse: false
+                });
+            });
+        });
+        plugins.forEach((_, name)=>{
+            visit(name);
+        });
+        result = result.filter((result)=>result);
+        return result;
+    };
+    const clear = ()=>{
+        plugins.clear();
+        dependencies.clear();
+    };
+    return {
+        getPlugins,
+        addPlugins,
+        clear,
+        isPluginExists: (name)=>plugins.has(name)
+    };
+}
+export { createPluginManager };

package/dist/esm-node/runtime/api.mjs

@@ -0,0 +1,62 @@
+import "node:module";
+import { merge } from "@modern-js/runtime-utils/merge";
+function initPluginAPI({ context, plugins }) {
+    const { hooks, extendsHooks } = context;
+    function getRuntimeContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, pluginAPI, ...runtimeContext } = context;
+            runtimeContext._internalContext = context;
+            return runtimeContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function updateRuntimeContext(updateContext) {
+        context = merge(context, updateContext);
+    }
+    function getHooks() {
+        return {
+            ...hooks,
+            ...extendsHooks
+        };
+    }
+    function getRuntimeConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getRuntimeContext, updateRuntimeContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    const pluginAPI = {
+        updateRuntimeContext,
+        getHooks,
+        getRuntimeConfig,
+        config: hooks.config.tap,
+        onBeforeRender: hooks.onBeforeRender.tap,
+        wrapRoot: hooks.wrapRoot.tap,
+        pickContext: hooks.pickContext.tap,
+        extendStringSSRCollectors: hooks.extendStringSSRCollectors.tap,
+        extendStreamSSR: hooks.extendStreamSSR.tap,
+        ...extendsPluginApi
+    };
+    if ("u" < typeof Proxy) return pluginAPI;
+    return new Proxy(pluginAPI, {
+        get (target, prop) {
+            if ('then' === prop) return;
+            if (prop in target) return target[prop];
+            return ()=>{
+                console.warn(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+export { initPluginAPI };

package/dist/esm-node/runtime/context.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { initHooks } from "./hooks.mjs";
+function initRuntimeContext() {
+    return {};
+}
+function createRuntimeContext({ runtimeContext, config, plugins }) {
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...runtimeContext,
+        hooks: {
+            ...initHooks(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config
+    };
+}
+export { createRuntimeContext, initRuntimeContext };

package/dist/esm-node/runtime/hooks.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
+function initHooks() {
+    return {
+        onBeforeRender: createAsyncInterruptHook(),
+        wrapRoot: createSyncHook(),
+        pickContext: createSyncHook(),
+        config: createCollectSyncHook(),
+        extendStringSSRCollectors: createCollectSyncHook(),
+        extendStreamSSR: createCollectSyncHook()
+    };
+}
+export { initHooks };