@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/cjs/ultramodern/designSystem.js

@@ -0,0 +1,119 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DESIGN_SYSTEM_MODES: ()=>DESIGN_SYSTEM_MODES,
+    DESIGN_SYSTEM_OVERRIDE_LAYERS: ()=>DESIGN_SYSTEM_OVERRIDE_LAYERS,
+    createDesignSystemTokenPackMap: ()=>createDesignSystemTokenPackMap,
+    validateDesignSystemConsumerCompatibility: ()=>validateDesignSystemConsumerCompatibility,
+    validateDesignSystemContract: ()=>validateDesignSystemContract
+});
+const DESIGN_SYSTEM_MODES = [
+    'off',
+    'tokens',
+    'components',
+    'strict'
+];
+const DESIGN_SYSTEM_OVERRIDE_LAYERS = [
+    'brand',
+    'vertical',
+    'application'
+];
+const VALID_MODES = new Set(DESIGN_SYSTEM_MODES);
+const VALID_OVERRIDE_LAYERS = new Set(DESIGN_SYSTEM_OVERRIDE_LAYERS);
+const createValidationResult = (issues)=>({
+        valid: 0 === issues.length,
+        issues
+    });
+const addIssue = (issues, path, message)=>{
+    issues.push({
+        path,
+        message
+    });
+};
+const createDesignSystemTokenPackMap = (tokenPacks)=>new Map(tokenPacks.map((tokenPack)=>[
+            tokenPack.id,
+            tokenPack
+        ]));
+const validateDesignSystemConsumerCompatibility = (vertical, tokenPack, path = 'vertical')=>{
+    const issues = [];
+    const consumers = vertical.consumers ?? [];
+    for (const [consumerIndex, consumer] of consumers.entries()){
+        const consumerPath = `${path}.consumers[${consumerIndex}]`;
+        if (consumer.unsupportedModes?.includes(vertical.mode)) addIssue(issues, `${consumerPath}.unsupportedModes`, `consumer "${consumer.id}" does not support "${vertical.mode}" mode`);
+        if (!tokenPack) continue;
+        const expectedVersion = consumer.tokenPackVersions?.[tokenPack.id];
+        if (expectedVersion && expectedVersion !== tokenPack.version) addIssue(issues, `${consumerPath}.tokenPackVersions.${tokenPack.id}`, `consumer "${consumer.id}" requires "${tokenPack.id}" version "${expectedVersion}" but received "${tokenPack.version}"`);
+        for (const tokenName of consumer.requiredTokens ?? [])if (!(tokenName in tokenPack.tokens)) addIssue(issues, `${consumerPath}.requiredTokens`, `consumer "${consumer.id}" requires missing token "${tokenName}" from "${tokenPack.id}"`);
+    }
+    return createValidationResult(issues);
+};
+const validateDesignSystemContract = (contract)=>{
+    const issues = [];
+    const tokenPackMap = createDesignSystemTokenPackMap(contract.tokenPacks);
+    for (const [tokenPackIndex, tokenPack] of contract.tokenPacks.entries()){
+        const tokenPackPath = `tokenPacks[${tokenPackIndex}]`;
+        if (tokenPackMap.get(tokenPack.id) !== tokenPack) addIssue(issues, `${tokenPackPath}.id`, `duplicate token pack id "${tokenPack.id}"`);
+        if (0 === Object.keys(tokenPack.tokens).length) addIssue(issues, `${tokenPackPath}.tokens`, `token pack "${tokenPack.id}" must define at least one token`);
+    }
+    for (const [verticalName, vertical] of Object.entries(contract.verticals)){
+        const verticalPath = `verticals.${verticalName}`;
+        const tokenPack = vertical.tokenPack ? tokenPackMap.get(vertical.tokenPack) : void 0;
+        if (!VALID_MODES.has(vertical.mode)) addIssue(issues, `${verticalPath}.mode`, `unsupported design system mode "${vertical.mode}"`);
+        if ('off' !== vertical.mode && !vertical.tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `vertical "${verticalName}" must select a token pack when mode is "${vertical.mode}"`);
+        if (vertical.tokenPack && !tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `unknown token pack "${vertical.tokenPack}"`);
+        for (const [overrideIndex, override] of (vertical.overrides ?? []).entries())if (!VALID_OVERRIDE_LAYERS.has(override.layer)) addIssue(issues, `${verticalPath}.overrides[${overrideIndex}].layer`, `override layer "${override.layer}" is not approved`);
+        if (vertical.pin) {
+            const pinnedTokenPack = tokenPackMap.get(vertical.pin.tokenPack);
+            const rollbackTokenPack = tokenPackMap.get(vertical.pin.rollback.tokenPack);
+            if (pinnedTokenPack) {
+                if (pinnedTokenPack.version !== vertical.pin.version) addIssue(issues, `${verticalPath}.pin.version`, `pinned version "${vertical.pin.version}" does not match token pack "${vertical.pin.tokenPack}" version "${pinnedTokenPack.version}"`);
+            } else addIssue(issues, `${verticalPath}.pin.tokenPack`, `unknown pinned token pack "${vertical.pin.tokenPack}"`);
+            if (vertical.tokenPack && vertical.pin.tokenPack !== vertical.tokenPack) addIssue(issues, `${verticalPath}.pin.tokenPack`, `pinned token pack "${vertical.pin.tokenPack}" must match selected token pack "${vertical.tokenPack}"`);
+            if (rollbackTokenPack) {
+                if (rollbackTokenPack.version !== vertical.pin.rollback.version) addIssue(issues, `${verticalPath}.pin.rollback.version`, `rollback version "${vertical.pin.rollback.version}" does not match token pack "${vertical.pin.rollback.tokenPack}" version "${rollbackTokenPack.version}"`);
+            } else addIssue(issues, `${verticalPath}.pin.rollback.tokenPack`, `unknown rollback token pack "${vertical.pin.rollback.tokenPack}"`);
+            if (!vertical.pin.rollback.reason) addIssue(issues, `${verticalPath}.pin.rollback.reason`, 'rollback metadata must include a reason');
+        }
+        const compatibility = validateDesignSystemConsumerCompatibility(vertical, tokenPack, verticalPath);
+        issues.push(...compatibility.issues);
+    }
+    return createValidationResult(issues);
+};
+exports.DESIGN_SYSTEM_MODES = __webpack_exports__.DESIGN_SYSTEM_MODES;
+exports.DESIGN_SYSTEM_OVERRIDE_LAYERS = __webpack_exports__.DESIGN_SYSTEM_OVERRIDE_LAYERS;
+exports.createDesignSystemTokenPackMap = __webpack_exports__.createDesignSystemTokenPackMap;
+exports.validateDesignSystemConsumerCompatibility = __webpack_exports__.validateDesignSystemConsumerCompatibility;
+exports.validateDesignSystemContract = __webpack_exports__.validateDesignSystemContract;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DESIGN_SYSTEM_MODES",
+    "DESIGN_SYSTEM_OVERRIDE_LAYERS",
+    "createDesignSystemTokenPackMap",
+    "validateDesignSystemConsumerCompatibility",
+    "validateDesignSystemContract"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/config.js

@@ -0,0 +1,45 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    emitResolvedConfig: ()=>emitResolvedConfig
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_flatted_namespaceObject = require("flatted");
+const external_path_namespaceObject = require("path");
+const emitResolvedConfig = async (appDirectory, resolvedConfig)=>{
+    const outputPath = (0, utils_namespaceObject.ensureAbsolutePath)(appDirectory, external_path_namespaceObject.join(resolvedConfig.output.distPath?.root || './dist', utils_namespaceObject.OUTPUT_CONFIG_FILE));
+    const output = (0, external_flatted_namespaceObject.stringify)(resolvedConfig);
+    await utils_namespaceObject.fs.writeFile(outputPath, output, {
+        encoding: 'utf-8'
+    });
+};
+exports.emitResolvedConfig = __webpack_exports__.emitResolvedConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "emitResolvedConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/createServer.js

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    closeServer: ()=>closeServer,
+    getServer: ()=>getServer,
+    setServer: ()=>setServer
+});
+let server = null;
+const getServer = ()=>server;
+const setServer = (newServer)=>{
+    server = newServer;
+};
+const closeServer = async ()=>{
+    if (server) {
+        server.close();
+        server = null;
+    }
+};
+exports.closeServer = __webpack_exports__.closeServer;
+exports.getServer = __webpack_exports__.getServer;
+exports.setServer = __webpack_exports__.setServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "closeServer",
+    "getServer",
+    "setServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/env.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getAutoInjectEnv: ()=>getAutoInjectEnv
+});
+const universal_namespaceObject = require("@modern-js/utils/universal");
+function getAutoInjectEnv(appContext) {
+    const { metaName } = appContext;
+    const prefix = `${(0, universal_namespaceObject.cutNameByHyphen)(metaName)}_`.toUpperCase();
+    const envReg = new RegExp(`^${prefix}`);
+    return Object.keys(process.env).reduce((prev, key)=>{
+        const value = process.env[key];
+        if (envReg.test(key) && void 0 !== value) prev[`process.env.${key}`] = value;
+        return prev;
+    }, {});
+}
+exports.getAutoInjectEnv = __webpack_exports__.getAutoInjectEnv;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getAutoInjectEnv"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/generateWatchFiles.js

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    generateWatchFiles: ()=>generateWatchFiles
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+async function generateWatchFiles(appContext, configDir) {
+    const { appDirectory, configFile } = appContext;
+    const configPath = external_path_default().join(appDirectory, configDir || '');
+    return [
+        `${configPath}/html`,
+        configFile || './config'
+    ];
+}
+exports.generateWatchFiles = __webpack_exports__.generateWatchFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateWatchFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/getConfigFile.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getConfigFile: ()=>getConfigFile
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../constants.js");
+const getConfigFile = (configFile, cwd = process.cwd())=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.CONFIG_FILE_EXTENSIONS.map((extension)=>external_path_default().resolve(cwd, `${configFile || external_constants_js_namespaceObject.DEFAULT_CONFIG_FILE}${extension}`)));
+exports.getConfigFile = __webpack_exports__.getConfigFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getConfigFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/getSelectedEntries.js

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getSelectedEntries: ()=>getSelectedEntries
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../locale/index.js");
+const getSelectedEntries = async (entry, entrypoints)=>{
+    const entryNames = entrypoints.map((e)=>e.entryName);
+    if (!entry) return entryNames;
+    if ('boolean' == typeof entry) {
+        const { selected } = await utils_namespaceObject.inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selected',
+                choices: entryNames,
+                message: index_js_namespaceObject.i18n.t(index_js_namespaceObject.localeKeys.command.dev.selectEntry),
+                validate (answer) {
+                    if (answer.length < 1) return index_js_namespaceObject.i18n.t(index_js_namespaceObject.localeKeys.command.dev.requireEntry);
+                    return true;
+                }
+            }
+        ]);
+        return selected;
+    }
+    entry.forEach((name)=>{
+        if (!entryNames.includes(name)) throw new Error(`Can not found entry ${utils_namespaceObject.chalk.yellow(name)}, the entry should be one of ${utils_namespaceObject.chalk.yellow(entryNames.join(', '))}`);
+    });
+    return entry;
+};
+exports.getSelectedEntries = __webpack_exports__.getSelectedEntries;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getSelectedEntries"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/initAppContext.js

@@ -0,0 +1,71 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initAppContext: ()=>initAppContext
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, tempDir })=>{
+    const { apiDir = 'api', sharedDir = 'shared', bffRuntimeFramework = 'hono' } = options || {};
+    const pkgPath = external_path_default().resolve(appDirectory, './package.json');
+    const moduleType = utils_namespaceObject.fs.existsSync(pkgPath) ? utils_namespaceObject.fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
+    return {
+        runtimeConfigFile,
+        ip: utils_namespaceObject.address.ip(),
+        port: 0,
+        moduleType,
+        apiDirectory: external_path_default().resolve(appDirectory, apiDir),
+        lambdaDirectory: external_path_default().resolve(appDirectory, apiDir, 'lambda'),
+        sharedDirectory: external_path_default().resolve(appDirectory, sharedDir),
+        serverPlugins: [],
+        internalDirectory: external_path_default().resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
+        htmlTemplates: {},
+        serverRoutes: [],
+        entrypoints: [],
+        checkedEntries: [],
+        apiOnly: false,
+        internalDirAlias: `@_${metaName.replace(/-/g, '_')}_internal`,
+        internalSrcAlias: `@_${metaName.replace(/-/g, '_')}_src`,
+        bffRuntimeFramework
+    };
+};
+exports.initAppContext = __webpack_exports__.initAppContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initAppContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/loadPlugins.js

@@ -0,0 +1,85 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getServerPlugins: ()=>getServerPlugins,
+    loadInternalPlugins: ()=>loadInternalPlugins,
+    loadServerPlugins: ()=>loadServerPlugins
+});
+const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
+const debug = (0, utils_namespaceObject.createDebugger)('load-plugins');
+async function getServerPlugins(api, metaName = 'modern-js') {
+    const hooks = api.getHooks();
+    const { plugins } = await hooks._internalServerPlugins.call({
+        plugins: []
+    });
+    const filtedPlugins = plugins.filter((plugin)=>plugin.name.includes(metaName));
+    api.updateAppContext({
+        serverPlugins: filtedPlugins
+    });
+    return filtedPlugins;
+}
+async function loadServerPlugins(api, appDirectory, metaName) {
+    const plugins = await getServerPlugins(api, metaName);
+    const instances = await (0, node_namespaceObject.loadServerPlugins)(plugins, appDirectory);
+    return instances;
+}
+const resolveCliPlugin = async (p, appDirectory)=>{
+    const pkg = 'string' == typeof p ? p : p[0];
+    const pluginOptions = 'string' == typeof p ? void 0 : p[1];
+    const path = (0, utils_namespaceObject.tryResolve)(pkg, appDirectory);
+    let module;
+    try {
+        module = await (0, utils_namespaceObject.compatibleRequire)(path);
+    } catch (e) {
+        ({ default: module } = await (0, utils_namespaceObject.dynamicImport)(path));
+    }
+    if ('function' == typeof module) {
+        const result = module(pluginOptions);
+        return result;
+    }
+    return module;
+};
+const loadInternalPlugins = async (appDirectory, internalPlugins)=>{
+    const plugins = (0, utils_namespaceObject.getInternalPlugins)(appDirectory, internalPlugins);
+    const loadedPlugins = await Promise.all(plugins.map((plugin)=>{
+        const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+        debug("resolve plugin %s: %s", plugin, loadedPlugin);
+        return loadedPlugin;
+    }));
+    return loadedPlugins;
+};
+exports.getServerPlugins = __webpack_exports__.getServerPlugins;
+exports.loadInternalPlugins = __webpack_exports__.loadInternalPlugins;
+exports.loadServerPlugins = __webpack_exports__.loadServerPlugins;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getServerPlugins",
+    "loadInternalPlugins",
+    "loadServerPlugins"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/printInstructions.js

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    printInstructions: ()=>printInstructions
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const printInstructions = async (hooks, appContext, config)=>{
+    const message = (0, utils_namespaceObject.prettyInstructions)(appContext, config);
+    const { instructions } = await hooks.onBeforePrintInstructions.call({
+        instructions: message
+    });
+    utils_namespaceObject.logger.log(instructions);
+};
+exports.printInstructions = __webpack_exports__.printInstructions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "printInstructions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});