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

package/dist/esm/runtime/run/create.mjs

@@ -0,0 +1,45 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager.mjs";
+import { initPluginAPI } from "../api.mjs";
+import { createRuntimeContext, initRuntimeContext } from "../context.mjs";
+const createRuntime = ()=>{
+    let initOptions;
+    const pluginManager = createPluginManager();
+    function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { plugins: allPlugins, handleSetupResult } = options;
+        pluginManager.addPlugins(allPlugins);
+        const plugins = pluginManager.getPlugins();
+        const context = createRuntimeContext({
+            runtimeContext: initRuntimeContext(),
+            config: initOptions.config,
+            plugins
+        });
+        const pluginAPI = initPluginAPI({
+            context,
+            pluginManager,
+            plugins
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = plugin.setup?.(pluginAPI);
+            if (handleSetupResult) handleSetupResult(setupResult, pluginAPI);
+        }
+        return {
+            runtimeContext: context
+        };
+    }
+    function run(options) {
+        const { runtimeContext } = init(options);
+        const configs = runtimeContext.hooks.config.call().filter((config)=>Boolean(config));
+        runtimeContext.config = merge({}, ...configs, runtimeContext.config || {});
+        return {
+            runtimeContext
+        };
+    }
+    return {
+        run
+    };
+};
+export { createRuntime };

package/dist/esm/runtime/run/index.mjs

@@ -0,0 +1,3 @@
+import { createRuntime } from "./create.mjs";
+const runtime = createRuntime();
+export { runtime };

package/dist/esm/server/api.mjs

@@ -0,0 +1,59 @@
+import { createDebugger } from "@modern-js/utils";
+import { assign as lodash_assign } from "@modern-js/utils/lodash";
+const debug = createDebugger('plugin-server-v2');
+function initPluginAPI({ context, pluginManager }) {
+    const { hooks, extendsHooks, plugins } = context;
+    function getServerContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, pluginAPI, ...serverContext } = context;
+            serverContext._internalContext = context;
+            return serverContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function getConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    function getHooks() {
+        return context.hooks;
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getServerContext, updateServerContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    function updateServerContext(updateContext) {
+        context = lodash_assign(context, updateContext);
+    }
+    const pluginAPI = {
+        isPluginExists: pluginManager.isPluginExists,
+        getServerContext,
+        getServerConfig: getConfig,
+        getHooks,
+        updateServerContext,
+        modifyConfig: hooks.modifyConfig.tap,
+        onPrepare: hooks.onPrepare.tap,
+        onReset: hooks.onReset.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 ()=>{
+                debug(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+export { debug, initPluginAPI };

package/dist/esm/server/context.mjs

@@ -0,0 +1,38 @@
+import { initHooks } from "./hooks.mjs";
+function initServerContext(params) {
+    const { options, plugins } = params;
+    return {
+        routes: options.routes || [],
+        appDirectory: options.appContext.appDirectory || '',
+        apiDirectory: options.appContext.apiDirectory,
+        lambdaDirectory: options.appContext.lambdaDirectory,
+        internalDirectory: options.appContext.internalDirectory || '',
+        sharedDirectory: options.appContext.sharedDirectory || '',
+        distDirectory: options.pwd,
+        metaName: options.metaName || 'modern-js',
+        plugins: plugins,
+        middlewares: [],
+        bffRuntimeFramework: options.appContext.bffRuntimeFramework,
+        renderMiddlewares: []
+    };
+}
+function createServerContext({ serverContext, config }) {
+    const { plugins } = serverContext;
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...serverContext,
+        hooks: {
+            ...initHooks(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config
+    };
+}
+export { createServerContext, initServerContext };

package/dist/esm/server/hooks.mjs

@@ -0,0 +1,9 @@
+import { createAsyncHook } from "../hooks.mjs";
+function initHooks() {
+    return {
+        modifyConfig: createAsyncHook(),
+        onPrepare: createAsyncHook(),
+        onReset: createAsyncHook()
+    };
+}
+export { initHooks };

package/dist/esm/server/index.mjs

@@ -0,0 +1,4 @@
+export { initPluginAPI } from "./api.mjs";
+export { createServerContext, initServerContext } from "./context.mjs";
+export { initHooks } from "./hooks.mjs";
+export { createServer, server } from "./run/index.mjs";

package/dist/esm/server/run/create.mjs

@@ -0,0 +1,45 @@
+import { createPluginManager } from "../../manager.mjs";
+import { initPluginAPI } from "../api.mjs";
+import { createServerContext, initServerContext } from "../context.mjs";
+const createServer = ()=>{
+    let initOptions;
+    const pluginManager = createPluginManager();
+    function init(options) {
+        pluginManager.clear();
+        initOptions = options;
+        const { plugins: allPlugins, options: runOptions, handleSetupResult } = initOptions;
+        pluginManager.addPlugins(allPlugins);
+        const plugins = pluginManager.getPlugins();
+        const context = createServerContext({
+            serverContext: initServerContext({
+                plugins,
+                options: runOptions
+            }),
+            config: initOptions.config
+        });
+        const pluginAPI = initPluginAPI({
+            context,
+            pluginManager
+        });
+        context.pluginAPI = pluginAPI;
+        for (const plugin of plugins){
+            const setupResult = plugin.setup?.(pluginAPI);
+            if (handleSetupResult) handleSetupResult(setupResult, pluginAPI);
+        }
+        return {
+            serverContext: context
+        };
+    }
+    async function run(options) {
+        const { serverContext } = init(options);
+        const config = await serverContext.hooks.modifyConfig.call(serverContext.config);
+        serverContext.config = config;
+        return {
+            serverContext
+        };
+    }
+    return {
+        run
+    };
+};
+export { createServer };

package/dist/esm/server/run/index.mjs

@@ -0,0 +1,3 @@
+import { createServer } from "./create.mjs";
+const server = createServer();
+export { createServer, server };

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

@@ -0,0 +1,86 @@
+import "node:module";
+import { assign as lodash_assign } from "@modern-js/utils/lodash";
+import { debug } from "./run/utils/debug.mjs";
+function initPluginAPI({ context, pluginManager }) {
+    const { hooks, extendsHooks, plugins } = context;
+    function getAppContext() {
+        if (context) {
+            const { hooks, extendsHooks, config, normalizedConfig, pluginAPI, ...appContext } = context;
+            appContext._internalContext = context;
+            return appContext;
+        }
+        throw new Error('Cannot access context');
+    }
+    function getConfig() {
+        if (context.config) return context.config;
+        throw new Error('Cannot access config');
+    }
+    function getNormalizedConfig() {
+        if (context.normalizedConfig) return context.normalizedConfig;
+        throw new Error('Cannot access normalized config');
+    }
+    function getHooks() {
+        return context.hooks;
+    }
+    const extendsPluginApi = {};
+    plugins.forEach((plugin)=>{
+        const { _registryApi } = plugin;
+        if (_registryApi) {
+            const apis = _registryApi(getAppContext, updateAppContext);
+            Object.keys(apis).forEach((apiName)=>{
+                extendsPluginApi[apiName] = apis[apiName];
+            });
+        }
+    });
+    if (extendsHooks) Object.keys(extendsHooks).forEach((hookName)=>{
+        extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+    function updateAppContext(updateContext) {
+        context = lodash_assign(context, updateContext);
+    }
+    const pluginAPI = {
+        isPluginExists: pluginManager.isPluginExists,
+        getAppContext,
+        getConfig,
+        getNormalizedConfig,
+        getHooks,
+        updateAppContext,
+        config: hooks.config.tap,
+        modifyConfig: hooks.modifyConfig.tap,
+        modifyResolvedConfig: hooks.modifyResolvedConfig.tap,
+        modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
+        modifyBundlerChain: hooks.modifyBundlerChain.tap,
+        modifyRspackConfig: hooks.modifyRspackConfig.tap,
+        modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+        addCommand: hooks.addCommand.tap,
+        onPrepare: hooks.onPrepare.tap,
+        addWatchFiles: hooks.addWatchFiles.tap,
+        onFileChanged: hooks.onFileChanged.tap,
+        onBeforeRestart: hooks.onBeforeRestart.tap,
+        onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+        onDevCompileDone: hooks.onDevCompileDone.tap,
+        onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
+        onBeforeBuild: hooks.onBeforeBuild.tap,
+        onAfterBuild: hooks.onAfterBuild.tap,
+        onBeforeDev: hooks.onBeforeDev.tap,
+        onAfterDev: hooks.onAfterDev.tap,
+        onBeforeDeploy: hooks.onBeforeDeploy.tap,
+        onAfterDeploy: hooks.onAfterDeploy.tap,
+        onBeforeExit: hooks.onBeforeExit.tap,
+        _internalRuntimePlugins: hooks._internalRuntimePlugins.tap,
+        _internalServerPlugins: hooks._internalServerPlugins.tap,
+        modifyServerRoutes: hooks.modifyServerRoutes.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 ()=>{
+                debug(`api.${prop.toString()} not exist`);
+            };
+        }
+    });
+}
+export { initPluginAPI };

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

@@ -0,0 +1,39 @@
+import "node:module";
+import path from "path";
+import { initHooks } from "./hooks.mjs";
+function initAppContext(params) {
+    const { appDirectory, srcDir = 'src', distDir = 'dist' } = params;
+    return {
+        metaName: params.metaName,
+        packageName: params.packageName,
+        configFile: params.configFile,
+        command: params.command,
+        isProd: 'production' === process.env.NODE_ENV,
+        appDirectory: appDirectory,
+        srcDirectory: path.resolve(appDirectory, srcDir),
+        distDirectory: '',
+        nodeModulesDirectory: path.resolve(appDirectory, 'node_modules'),
+        plugins: params.plugins
+    };
+}
+async function createContext({ appContext, config, normalizedConfig }) {
+    const { plugins } = appContext;
+    const extendsHooks = {};
+    plugins.forEach((plugin)=>{
+        const { registryHooks = {} } = plugin;
+        Object.keys(registryHooks).forEach((hookName)=>{
+            extendsHooks[hookName] = registryHooks[hookName];
+        });
+    });
+    return {
+        ...appContext,
+        hooks: {
+            ...initHooks(),
+            ...extendsHooks
+        },
+        extendsHooks,
+        config,
+        normalizedConfig
+    };
+}
+export { createContext, initAppContext };

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

@@ -0,0 +1,32 @@
+import "node:module";
+import { createAsyncHook, createCollectAsyncHook } from "../hooks.mjs";
+function initHooks() {
+    return {
+        config: createCollectAsyncHook(),
+        modifyConfig: createAsyncHook(),
+        modifyResolvedConfig: createAsyncHook(),
+        modifyRsbuildConfig: createAsyncHook(),
+        modifyBundlerChain: createAsyncHook(),
+        modifyRspackConfig: createAsyncHook(),
+        modifyHtmlPartials: createAsyncHook(),
+        addCommand: createAsyncHook(),
+        addWatchFiles: createCollectAsyncHook(),
+        onPrepare: createAsyncHook(),
+        onFileChanged: createAsyncHook(),
+        onBeforeRestart: createAsyncHook(),
+        onBeforeCreateCompiler: createAsyncHook(),
+        onAfterCreateCompiler: createAsyncHook(),
+        onDevCompileDone: createAsyncHook(),
+        onBeforeBuild: createAsyncHook(),
+        onAfterBuild: createAsyncHook(),
+        onBeforeDev: createAsyncHook(),
+        onAfterDev: createAsyncHook(),
+        onBeforeDeploy: createAsyncHook(),
+        onAfterDeploy: createAsyncHook(),
+        onBeforeExit: createAsyncHook(),
+        _internalRuntimePlugins: createAsyncHook(),
+        _internalServerPlugins: createAsyncHook(),
+        modifyServerRoutes: createAsyncHook()
+    };
+}
+export { initHooks };

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

@@ -0,0 +1,7 @@
+import "node:module";
+export { initPluginAPI } from "./api.mjs";
+export { createContext, initAppContext } from "./context.mjs";
+export { initHooks } from "./hooks.mjs";
+export { cli, createCli, createLoadedConfig, initAppDir } from "./run/index.mjs";
+export { createConfigOptions, createStorybookOptions } from "./run/create.mjs";
+export { mergeConfig } from "./run/utils/mergeConfig.mjs";

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

@@ -0,0 +1,54 @@
+import "node:module";
+import { CONFIG_FILE_EXTENSIONS, chalk, fs, getCommand, getNodeEnv, isDevCommand, logger } from "@modern-js/utils";
+import { mergeConfig } from "../utils/mergeConfig.mjs";
+import { getConfigFilePath, loadConfig } from "./loadConfig.mjs";
+async function getConfigObject(config) {
+    if ('function' == typeof config) return await config({
+        env: getNodeEnv(),
+        command: getCommand()
+    }) || {};
+    return config || {};
+}
+async function loadLocalConfig(appDirectory, configFile) {
+    let localConfigFile = false;
+    if ('string' == typeof configFile) {
+        for (const ext of CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
+            const replacedPath = configFile.replace(ext, `.local${ext}`);
+            if (fs.existsSync(replacedPath)) localConfigFile = replacedPath;
+        }
+    }
+    if (localConfigFile) {
+        const loaded = await loadConfig(appDirectory, localConfigFile);
+        return getConfigObject(loaded.config);
+    }
+    return null;
+}
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+    const configFile = getConfigFilePath(appDirectory, configFilePath);
+    const loaded = await loadConfig(appDirectory, configFile);
+    if (!loaded.config && !loaded.pkgConfig) {
+        logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
+        logger.warn(`Current project path: ${chalk.yellow(appDirectory)}`);
+    }
+    const config = await getConfigObject(loaded.config);
+    let mergedConfig = config;
+    if (isDevCommand()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile);
+        if (localConfig) mergedConfig = mergeConfig([
+            mergedConfig,
+            localConfig
+        ]);
+    }
+    if (otherConfig) mergedConfig = mergeConfig([
+        mergedConfig,
+        otherConfig
+    ]);
+    return {
+        packageName: loaded.packageName,
+        config: mergedConfig,
+        configFile: loaded.configFile,
+        pkgConfig: loaded.pkgConfig,
+        jsConfig: loaded.config
+    };
+}
+export { createLoadedConfig };

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

@@ -0,0 +1,15 @@
+import "node:module";
+import { createDebugger } from "@modern-js/utils";
+import { mergeConfig } from "../utils/mergeConfig.mjs";
+const debug = createDebugger('resolve-config');
+const createResolveConfig = async (loaded, configs)=>{
+    const { config: userConfig } = loaded;
+    const resolved = mergeConfig([
+        {},
+        ...configs,
+        userConfig
+    ]);
+    debug('resolved %o', resolved);
+    return resolved;
+};
+export { createResolveConfig };

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

@@ -0,0 +1,63 @@
+import "node:module";
+import { compatibleRequire, fs, globby } from "@modern-js/utils";
+import { createJiti } from "jiti";
+import path from "path";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var loadConfig_filename = __rspack_fileURLToPath(import.meta.url);
+const getConfigFilePath = (appDirectory, configFilePath)=>{
+    if (path.isAbsolute(configFilePath)) return configFilePath;
+    return path.resolve(appDirectory, configFilePath);
+};
+const clearFilesOverTime = async (targetDir, overtime)=>{
+    try {
+        const files = await globby(`${targetDir}/**/*`, {
+            stats: true,
+            absolute: true
+        });
+        const currentTime = Date.now();
+        if (files.length > 0) {
+            for (const file of files)if (currentTime - file.stats.birthtimeMs >= 1000 * overtime) fs.unlinkSync(file.path);
+        }
+    } catch (err) {}
+};
+async function loadConfigContent(configFile) {
+    const jitiFrom = import.meta.url;
+    const jiti = createJiti(jitiFrom, {
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!fs.existsSync(configFile)) throw new Error(`Configuration file does not exist: ${configFile}`);
+    try {
+        let config;
+        config = await jiti.import(configFile, {});
+        return config.default || config;
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading config file: ${configFile}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+}
+const loadTypeScriptFile = (filePath)=>{
+    const jiti = createJiti(loadConfig_filename, {
+        requireCache: false,
+        interopDefault: true
+    });
+    if (!fs.existsSync(filePath)) throw new Error(`TypeScript file does not exist: ${filePath}`);
+    try {
+        return jiti(filePath);
+    } catch (e) {
+        if (e instanceof Error) e.message = `Get Error while loading TypeScript file: ${filePath}, please check it and retry.\n${e.message || ''}`;
+        throw e;
+    }
+};
+const loadConfig = async (appDirectory, configFile)=>{
+    const pkg = await compatibleRequire(path.resolve(appDirectory, './package.json'));
+    const packageName = pkg.name;
+    let config;
+    if (configFile) config = await loadConfigContent(configFile);
+    return {
+        packageName,
+        configFile,
+        config
+    };
+};
+export { clearFilesOverTime, getConfigFilePath, loadConfig, loadTypeScriptFile };