@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/dist/cjs/deploy-output/public-assets.js

@@ -0,0 +1,146 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    CLOUDFLARE_PUBLIC_ASSET_SCOPE: ()=>CLOUDFLARE_PUBLIC_ASSET_SCOPE,
+    DECLARED_PUBLIC_ASSET_DIRECTORY: ()=>DECLARED_PUBLIC_ASSET_DIRECTORY,
+    NODE_PUBLIC_ASSET_SCOPE: ()=>NODE_PUBLIC_ASSET_SCOPE,
+    normalizeDeclaredPublicAssets: ()=>normalizeDeclaredPublicAssets,
+    resolveAddedDeclaredPublicAssetPaths: ()=>resolveAddedDeclaredPublicAssetPaths,
+    stageDeclaredPublicAssets: ()=>stageDeclaredPublicAssets
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_js_namespaceObject = require("../cloudflare/utils.js");
+const DECLARED_PUBLIC_ASSET_DIRECTORY = 'public';
+const CLOUDFLARE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.worker.publicAssets',
+    output: 'Cloudflare public output'
+};
+const NODE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.node.publicAssets',
+    output: 'Node public output'
+};
+const normalizeDeclaredPublicAssets = (assets, scope)=>(assets ?? []).map((asset, index)=>({
+            from: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.from, `${scope.label}[${index}].from`, 'app root'),
+            to: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.to, `${scope.label}[${index}].to`, scope.output, {
+                allowRoot: true
+            }),
+            index
+        }));
+const isMissingPathError = (error)=>error instanceof Error && 'code' in error && 'ENOENT' === error.code;
+const pathExists = async (filePath)=>{
+    try {
+        await promises_default().lstat(filePath);
+        return true;
+    } catch (error) {
+        if (isMissingPathError(error)) return false;
+        throw error;
+    }
+};
+const listDeclaredPublicAssetFiles = async (appDirectory, assets, scope)=>{
+    const files = [];
+    const owners = new Map();
+    const add = (index, logicalPath)=>{
+        const owner = owners.get(logicalPath);
+        if (void 0 !== owner) throw new Error(`${scope.label}[${index}] and ${scope.label}[${owner}] both stage ${JSON.stringify(logicalPath)}.`);
+        owners.set(logicalPath, index);
+        files.push({
+            index,
+            logicalPath
+        });
+    };
+    const visit = async (asset, sourcePath, destination)=>{
+        const stat = await promises_default().lstat(sourcePath);
+        if (stat.isSymbolicLink()) throw new Error(`${scope.label}[${asset.index}].from must not contain symbolic links: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        if (stat.isFile()) {
+            if (destination === DECLARED_PUBLIC_ASSET_DIRECTORY) throw new Error(`${scope.label}[${asset.index}].to must name a file when ${scope.label}[${asset.index}].from is a file.`);
+            add(asset.index, destination);
+            return;
+        }
+        if (!stat.isDirectory()) throw new Error(`${scope.label}[${asset.index}].from must contain only files and directories: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        const entries = (await promises_default().readdir(sourcePath)).sort();
+        for (const entry of entries)await visit(asset, external_node_path_default().join(sourcePath, entry), external_node_path_default().posix.join(destination, entry));
+    };
+    for (const asset of assets){
+        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
+        if (!await pathExists(sourcePath)) throw new Error(`${scope.label}[${asset.index}].from does not exist: ${asset.from}`);
+        await visit(asset, sourcePath, external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to));
+    }
+    return files;
+};
+const resolveAddedDeclaredPublicAssetPaths = async ({ appDirectory, assets, generatedRoot, scope })=>{
+    const added = [];
+    for (const file of (await listDeclaredPublicAssetFiles(appDirectory, assets, scope)))if (!await pathExists(external_node_path_default().join(generatedRoot, file.logicalPath))) added.push(file.logicalPath);
+    return added.sort();
+};
+const stageDeclaredPublicAssets = async ({ appDirectory, outputDirectory, assets, scope })=>{
+    const files = await listDeclaredPublicAssetFiles(appDirectory, assets, scope);
+    const added = [];
+    for (const file of files){
+        const asset = assets.find((candidate)=>candidate.index === file.index);
+        const relativePath = external_node_path_default().posix.relative(external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to), file.logicalPath);
+        const destination = external_node_path_default().join(outputDirectory, file.logicalPath);
+        const replacesGeneratedFile = await pathExists(destination);
+        await promises_default().mkdir(external_node_path_default().dirname(destination), {
+            recursive: true
+        });
+        await promises_default().copyFile(external_node_path_default().join(appDirectory, asset.from, relativePath), destination);
+        if (!replacesGeneratedFile) added.push(file.logicalPath);
+    }
+    return added.sort();
+};
+exports.CLOUDFLARE_PUBLIC_ASSET_SCOPE = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSET_SCOPE;
+exports.DECLARED_PUBLIC_ASSET_DIRECTORY = __webpack_exports__.DECLARED_PUBLIC_ASSET_DIRECTORY;
+exports.NODE_PUBLIC_ASSET_SCOPE = __webpack_exports__.NODE_PUBLIC_ASSET_SCOPE;
+exports.normalizeDeclaredPublicAssets = __webpack_exports__.normalizeDeclaredPublicAssets;
+exports.resolveAddedDeclaredPublicAssetPaths = __webpack_exports__.resolveAddedDeclaredPublicAssetPaths;
+exports.stageDeclaredPublicAssets = __webpack_exports__.stageDeclaredPublicAssets;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_PUBLIC_ASSET_SCOPE",
+    "DECLARED_PUBLIC_ASSET_DIRECTORY",
+    "NODE_PUBLIC_ASSET_SCOPE",
+    "normalizeDeclaredPublicAssets",
+    "resolveAddedDeclaredPublicAssetPaths",
+    "stageDeclaredPublicAssets"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/target.js

@@ -28,9 +28,21 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    DEPLOY_TARGETS: ()=>DEPLOY_TARGETS,
+    DEPLOY_TARGET_FLAG: ()=>DEPLOY_TARGET_FLAG,
+    getDeployingTarget: ()=>getDeployingTarget,
     resolveDeployTarget: ()=>resolveDeployTarget
 });
+const utils_namespaceObject = require("@modern-js/utils");
 const external_std_env_namespaceObject = require("std-env");
+const DEPLOY_TARGETS = [
+    'node',
+    'vercel',
+    'netlify',
+    'ghPages',
+    'cloudflare'
+];
+const DEPLOY_TARGET_FLAG = '--deploy-target';
 const providerDeployTargets = {
     vercel: 'vercel',
     netlify: 'netlify',
@@ -38,9 +50,53 @@ const providerDeployTargets = {
     cloudflare_pages: 'cloudflare',
     cloudflare_workers: 'cloudflare'
 };
-const resolveDeployTarget = (config, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = external_std_env_namespaceObject.provider)=>config.deploy?.target || envDeployTarget || (detectedProvider ? providerDeployTargets[detectedProvider] : void 0) || 'node';
+const readDeployTargetFlag = (argv)=>{
+    for (const [index, arg] of argv.entries()){
+        if (arg === DEPLOY_TARGET_FLAG) {
+            const value = argv[index + 1];
+            if (void 0 === value || value.startsWith('-')) throw new Error(`${DEPLOY_TARGET_FLAG} needs a value.`);
+            return value;
+        }
+        if (arg.startsWith(`${DEPLOY_TARGET_FLAG}=`)) return arg.slice(DEPLOY_TARGET_FLAG.length + 1);
+    }
+};
+const assertDeployTarget = (target, source)=>{
+    if (!DEPLOY_TARGETS.includes(target)) throw new Error(`Unknown deploy target '${target}' from ${source}. Use one of: ${DEPLOY_TARGETS.join(', ')}.`);
+    return target;
+};
+const resolveDeployTarget = ({ argv = (0, utils_namespaceObject.getArgv)(), configTarget, env = process.env.MODERNJS_DEPLOY, provider = external_std_env_namespaceObject.provider } = {})=>{
+    const explicit = [
+        [
+            readDeployTargetFlag(argv),
+            DEPLOY_TARGET_FLAG
+        ],
+        [
+            configTarget,
+            'deploy.target'
+        ],
+        [
+            env,
+            'MODERNJS_DEPLOY'
+        ]
+    ].find(([target])=>target);
+    if (explicit?.[0]) return {
+        target: assertDeployTarget(explicit[0], explicit[1]),
+        explicit: true
+    };
+    return {
+        target: provider && providerDeployTargets[provider] || 'node',
+        explicit: false
+    };
+};
+const getDeployingTarget = ({ deployTarget, metaName })=>deployTarget && ('modern-js' === metaName || deployTarget.explicit) ? deployTarget.target : void 0;
+exports.DEPLOY_TARGETS = __webpack_exports__.DEPLOY_TARGETS;
+exports.DEPLOY_TARGET_FLAG = __webpack_exports__.DEPLOY_TARGET_FLAG;
+exports.getDeployingTarget = __webpack_exports__.getDeployingTarget;
 exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEPLOY_TARGETS",
+    "DEPLOY_TARGET_FLAG",
+    "getDeployingTarget",
     "resolveDeployTarget"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/deploy-output/trace-files.js

@@ -0,0 +1,99 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    createBuildHostIgnore: ()=>createBuildHostIgnore,
+    traceDeployFiles: ()=>traceDeployFiles
+});
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const SYSTEM_ROOTS = 'win32' === process.platform ? [] : [
+    '/dev',
+    '/etc',
+    '/proc',
+    '/run',
+    '/sys',
+    '/var/run'
+];
+const GLOB_SEGMENT = /[*?[{]/;
+const isInside = (parent, child)=>child === parent || child.startsWith(`${parent}${external_node_path_default().sep}`);
+const globRoot = (absolutePattern)=>{
+    const { root } = external_node_path_default().parse(absolutePattern);
+    const segments = absolutePattern.slice(root.length).split(external_node_path_default().sep);
+    const index = segments.findIndex((segment)=>GLOB_SEGMENT.test(segment));
+    return -1 === index ? void 0 : external_node_path_default().join(root, ...segments.slice(0, index));
+};
+const createBuildHostIgnore = (base)=>{
+    const wholeDirectories = new Set([
+        external_node_path_default().parse(external_node_path_default().resolve(base)).root,
+        external_node_path_default().resolve(external_node_os_default().homedir()),
+        external_node_path_default().resolve(external_node_os_default().tmpdir())
+    ]);
+    return (relativePath)=>{
+        const absolutePath = external_node_path_default().resolve(base, relativePath);
+        if (SYSTEM_ROOTS.some((root)=>isInside(root, absolutePath))) return true;
+        const root = globRoot(absolutePath);
+        return void 0 !== root && wholeDirectories.has(root);
+    };
+};
+const traceDeployFiles = ({ entryFiles, sourceDir, base = '/' })=>{
+    const resolvedBase = external_node_path_default().resolve(base);
+    const ignore = createBuildHostIgnore(resolvedBase);
+    try {
+        const options = {
+            base: resolvedBase,
+            processCwd: external_node_path_default().resolve(sourceDir || resolvedBase),
+            ignore
+        };
+        const entries = entryFiles.map((file)=>external_node_path_default().resolve(file));
+        return import("@vercel/nft").then(({ nodeFileTrace })=>nodeFileTrace(entries, options));
+    } catch (error) {
+        return Promise.reject(error);
+    }
+};
+exports.createBuildHostIgnore = __webpack_exports__.createBuildHostIgnore;
+exports.traceDeployFiles = __webpack_exports__.traceDeployFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuildHostIgnore",
+    "traceDeployFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation-config/exposes.js

@@ -0,0 +1,70 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    readModuleFederationConfigInspection: ()=>readModuleFederationConfigInspection,
+    readModuleFederationExposePaths: ()=>readModuleFederationExposePaths
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_inspect_js_namespaceObject = require("./inspect.js");
+const moduleFederationConfigFile = 'module-federation.config.ts';
+function readModuleFederationConfigInspection(workspaceRoot, appDirectory) {
+    const configPath = external_node_path_default().join(workspaceRoot, appDirectory, moduleFederationConfigFile);
+    if (!external_node_fs_default().existsSync(configPath)) return;
+    try {
+        const source = external_node_fs_default().readFileSync(configPath, 'utf-8');
+        return (0, external_inspect_js_namespaceObject.inspectModuleFederationConfigSource)(source, appDirectory, external_node_path_default().join(appDirectory, moduleFederationConfigFile));
+    } catch  {
+        return;
+    }
+}
+function readModuleFederationExposePaths(workspaceRoot, appDirectory) {
+    return readModuleFederationConfigInspection(workspaceRoot, appDirectory)?.exposePaths;
+}
+exports.readModuleFederationConfigInspection = __webpack_exports__.readModuleFederationConfigInspection;
+exports.readModuleFederationExposePaths = __webpack_exports__.readModuleFederationExposePaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "readModuleFederationConfigInspection",
+    "readModuleFederationExposePaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation-config/index.js

@@ -0,0 +1,73 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    findCreateModuleFederationConfigObject: ()=>external_syntax_js_namespaceObject.findCreateModuleFederationConfigObject,
+    findExportDefaultObject: ()=>external_syntax_js_namespaceObject.findExportDefaultObject,
+    inspectModuleFederationConfigSource: ()=>external_inspect_js_namespaceObject.inspectModuleFederationConfigSource,
+    locateCreateModuleFederationConfigObject: ()=>external_syntax_js_namespaceObject.locateCreateModuleFederationConfigObject,
+    parseArrayLiteral: ()=>external_object_literal_js_namespaceObject.parseArrayLiteral,
+    parseConfigModule: ()=>external_syntax_js_namespaceObject.parseConfigModule,
+    parseLiteralString: ()=>external_object_literal_js_namespaceObject.parseLiteralString,
+    parseObjectLiteral: ()=>external_object_literal_js_namespaceObject.parseObjectLiteral,
+    parseStaticExpression: ()=>external_syntax_js_namespaceObject.parseStaticExpression,
+    readModuleFederationConfigInspection: ()=>external_exposes_js_namespaceObject.readModuleFederationConfigInspection,
+    readModuleFederationExposePaths: ()=>external_exposes_js_namespaceObject.readModuleFederationExposePaths
+});
+const external_exposes_js_namespaceObject = require("./exposes.js");
+const external_inspect_js_namespaceObject = require("./inspect.js");
+const external_object_literal_js_namespaceObject = require("./object-literal.js");
+const external_syntax_js_namespaceObject = require("./syntax.js");
+exports.findCreateModuleFederationConfigObject = __webpack_exports__.findCreateModuleFederationConfigObject;
+exports.findExportDefaultObject = __webpack_exports__.findExportDefaultObject;
+exports.inspectModuleFederationConfigSource = __webpack_exports__.inspectModuleFederationConfigSource;
+exports.locateCreateModuleFederationConfigObject = __webpack_exports__.locateCreateModuleFederationConfigObject;
+exports.parseArrayLiteral = __webpack_exports__.parseArrayLiteral;
+exports.parseConfigModule = __webpack_exports__.parseConfigModule;
+exports.parseLiteralString = __webpack_exports__.parseLiteralString;
+exports.parseObjectLiteral = __webpack_exports__.parseObjectLiteral;
+exports.parseStaticExpression = __webpack_exports__.parseStaticExpression;
+exports.readModuleFederationConfigInspection = __webpack_exports__.readModuleFederationConfigInspection;
+exports.readModuleFederationExposePaths = __webpack_exports__.readModuleFederationExposePaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findCreateModuleFederationConfigObject",
+    "findExportDefaultObject",
+    "inspectModuleFederationConfigSource",
+    "locateCreateModuleFederationConfigObject",
+    "parseArrayLiteral",
+    "parseConfigModule",
+    "parseLiteralString",
+    "parseObjectLiteral",
+    "parseStaticExpression",
+    "readModuleFederationConfigInspection",
+    "readModuleFederationExposePaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation-config/inspect.js

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    inspectModuleFederationConfigSource: ()=>inspectModuleFederationConfigSource
+});
+const external_object_literal_js_namespaceObject = require("./object-literal.js");
+const external_syntax_js_namespaceObject = require("./syntax.js");
+function extractExposes(configPath, value) {
+    if (void 0 === value) return {
+        exposePaths: {},
+        exposes: []
+    };
+    const object = (0, external_object_literal_js_namespaceObject.parseObjectLiteral)(value);
+    if (object) {
+        if (object.hasSpread) throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object without spreads.`);
+        const exposePaths = {};
+        for (const [expose, source] of object.properties){
+            const exposePath = (0, external_object_literal_js_namespaceObject.parseLiteralString)(source);
+            if (void 0 !== exposePath) exposePaths[expose] = exposePath;
+        }
+        return {
+            exposePaths,
+            exposes: Array.from(object.properties.keys()).sort()
+        };
+    }
+    const array = (0, external_object_literal_js_namespaceObject.parseArrayLiteral)(value);
+    if (array) return {
+        exposePaths: {},
+        exposes: array.sort()
+    };
+    throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object or string array.`);
+}
+function extractDtsSettings(configPath, value, exposes) {
+    if ('false' === value) {
+        if (exposes.length > 0) throw new Error(`Module Federation DTS cannot be disabled for exposed app ${configPath}.`);
+        return {};
+    }
+    if (void 0 === value) return {};
+    const dts = (0, external_object_literal_js_namespaceObject.parseObjectLiteral)(value);
+    if (!dts || dts.hasSpread) throw new Error(`Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`);
+    const generateTypes = (0, external_object_literal_js_namespaceObject.parseObjectLiteral)(dts.properties.get('generateTypes'));
+    if (generateTypes?.hasSpread) throw new Error(`Cannot statically extract Module Federation generateTypes settings from ${configPath}; use a literal generateTypes object.`);
+    const compilerInstanceSource = generateTypes?.properties.get('compilerInstance');
+    return {
+        compilerInstance: (0, external_object_literal_js_namespaceObject.parseLiteralString)(compilerInstanceSource) ?? ('tsgoCompilerInstance' === compilerInstanceSource ? 'effect-tsgo' : void 0),
+        tsConfigPath: (0, external_object_literal_js_namespaceObject.parseLiteralString)(dts.properties.get('tsConfigPath'))
+    };
+}
+function hasHostOnlyNoExposesDeclaration(source) {
+    return ((0, external_syntax_js_namespaceObject.parseConfigModule)(source).comments ?? []).some((comment)=>/@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(comment.value));
+}
+function inspectModuleFederationConfigSource(source, appDir, configPath) {
+    const configObject = (0, external_syntax_js_namespaceObject.findCreateModuleFederationConfigObject)(source) ?? (0, external_syntax_js_namespaceObject.findExportDefaultObject)(source);
+    if (!configObject) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; export or pass a literal config object.`);
+    const properties = (0, external_object_literal_js_namespaceObject.parseObjectLiteral)(configObject);
+    if (!properties) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; expected a literal config object.`);
+    if (properties.hasSpread) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; top-level config spreads are not supported.`);
+    const { exposePaths, exposes } = extractExposes(configPath, properties.properties.get('exposes'));
+    const hostOnlyNoExposes = hasHostOnlyNoExposesDeclaration(source);
+    if (hostOnlyNoExposes && exposes.length > 0) throw new Error(`Module Federation host-only/no-exposes declaration conflicts with actual exposes in ${configPath}.`);
+    return {
+        appDir,
+        configPath,
+        dts: extractDtsSettings(configPath, properties.properties.get('dts'), exposes),
+        exposePaths,
+        exposes,
+        hostOnlyNoExposes
+    };
+}
+exports.inspectModuleFederationConfigSource = __webpack_exports__.inspectModuleFederationConfigSource;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "inspectModuleFederationConfigSource"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation-config/object-literal.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    parseArrayLiteral: ()=>parseArrayLiteral,
+    parseLiteralString: ()=>parseLiteralString,
+    parseObjectLiteral: ()=>parseObjectLiteral
+});
+const external_syntax_js_namespaceObject = require("./syntax.js");
+function parseLiteralString(source) {
+    const node = (0, external_syntax_js_namespaceObject.parseStaticExpression)(source);
+    if (node?.type === 'StringLiteral') return node.value;
+    if (node?.type === 'TemplateLiteral' && 0 === node.expressions.length) return node.quasis[0]?.value.cooked ?? void 0;
+}
+function parseObjectLiteral(source) {
+    const node = (0, external_syntax_js_namespaceObject.parseStaticExpression)(source);
+    if (void 0 === source || node?.type !== 'ObjectExpression') return;
+    const properties = new Map();
+    let hasSpread = false;
+    for (const property of node.properties){
+        if ('ObjectProperty' !== property.type || property.computed || property.shorthand) {
+            hasSpread = true;
+            continue;
+        }
+        const key = 'Identifier' === property.key.type ? property.key.name : 'StringLiteral' === property.key.type ? property.key.value : void 0;
+        const value = (0, external_syntax_js_namespaceObject.parseStaticExpression)(source.slice(property.value.start ?? 0, property.value.end ?? 0));
+        if (void 0 === key || properties.has(key) || !value || null == value.start || null == value.end) {
+            hasSpread = true;
+            continue;
+        }
+        const rawValue = source.slice(property.value.start ?? 0, property.value.end ?? 0);
+        properties.set(key, rawValue.slice(value.start, value.end));
+    }
+    return {
+        hasSpread,
+        properties
+    };
+}
+function parseArrayLiteral(source) {
+    const node = (0, external_syntax_js_namespaceObject.parseStaticExpression)(source);
+    if (void 0 === source || node?.type !== 'ArrayExpression') return;
+    const values = [];
+    for (const element of node.elements){
+        if (!element || 'SpreadElement' === element.type) return;
+        const value = parseLiteralString(source.slice(element.start ?? 0, element.end ?? 0));
+        if (void 0 === value) return;
+        values.push(value);
+    }
+    return values;
+}
+exports.parseArrayLiteral = __webpack_exports__.parseArrayLiteral;
+exports.parseLiteralString = __webpack_exports__.parseLiteralString;
+exports.parseObjectLiteral = __webpack_exports__.parseObjectLiteral;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseArrayLiteral",
+    "parseLiteralString",
+    "parseObjectLiteral"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});