@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/dist/cjs/ultramodern-workspace/index.cjs

@@ -28,6 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES: ()=>external_shared_patches_cjs_namespaceObject.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES,
     addUltramodernVertical: ()=>external_add_vertical_cjs_namespaceObject.addUltramodernVertical,
     generateUltramodernWorkspace: ()=>external_write_workspace_cjs_namespaceObject.generateUltramodernWorkspace,
     normalizeUltramodernBridgeConfig: ()=>external_bridge_config_cjs_namespaceObject.normalizeUltramodernBridgeConfig,
@@ -36,14 +37,17 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_add_vertical_cjs_namespaceObject = require("./add-vertical.cjs");
 const external_bridge_config_cjs_namespaceObject = require("./bridge-config.cjs");
+const external_shared_patches_cjs_namespaceObject = require("./shared-patches.cjs");
 const external_versions_cjs_namespaceObject = require("./versions.cjs");
 const external_write_workspace_cjs_namespaceObject = require("./write-workspace.cjs");
+exports.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = __webpack_exports__.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES;
 exports.addUltramodernVertical = __webpack_exports__.addUltramodernVertical;
 exports.generateUltramodernWorkspace = __webpack_exports__.generateUltramodernWorkspace;
 exports.normalizeUltramodernBridgeConfig = __webpack_exports__.normalizeUltramodernBridgeConfig;
 exports.planUltramodernVertical = __webpack_exports__.planUltramodernVertical;
 exports.ultramodernWorkspaceVersions = __webpack_exports__.ultramodernWorkspaceVersions;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES",
     "addUltramodernVertical",
     "generateUltramodernWorkspace",
     "normalizeUltramodernBridgeConfig",

package/dist/cjs/ultramodern-workspace/locales.cjs

@@ -149,24 +149,11 @@ function createAppPublicLocaleMessages(app, language, remotes = []) {
     return Object.assign({}, createAppLocaleMessages(app, language), ...remotes.map((remote)=>createAppLocaleMessages(remote, language)));
 }
 __webpack_require__.d(__webpack_exports__, {
-    createAppLocaleMessages: ()=>createAppLocaleMessages,
     createAppPublicLocaleMessages: ()=>createAppPublicLocaleMessages
-}, {
-    commonLocaleMessages: commonLocaleMessages,
-    createFallbackLocaleMessages: createFallbackLocaleMessages,
-    generatedLocaleResources: generatedLocaleResources
 });
-exports.commonLocaleMessages = __webpack_exports__.commonLocaleMessages;
-exports.createAppLocaleMessages = __webpack_exports__.createAppLocaleMessages;
 exports.createAppPublicLocaleMessages = __webpack_exports__.createAppPublicLocaleMessages;
-exports.createFallbackLocaleMessages = __webpack_exports__.createFallbackLocaleMessages;
-exports.generatedLocaleResources = __webpack_exports__.generatedLocaleResources;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "commonLocaleMessages",
-    "createAppLocaleMessages",
-    "createAppPublicLocaleMessages",
-    "createFallbackLocaleMessages",
-    "generatedLocaleResources"
+    "createAppPublicLocaleMessages"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/ultramodern-workspace/mf-validation/constants.cjs

@@ -0,0 +1,69 @@
+"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__);
+const moduleFederationConfigFile = 'module-federation.config.ts';
+const mfTypesArchive = 'dist/@mf-types.zip';
+const generatedMetadataPaths = [
+    '.modernjs/ultramodern.json'
+];
+const defaultAppRootDirs = [
+    'apps',
+    'verticals'
+];
+const skippedScanDirs = new Set([
+    '.git',
+    '.modernjs',
+    '.nx',
+    '.turbo',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+__webpack_require__.d(__webpack_exports__, {}, {
+    defaultAppRootDirs: defaultAppRootDirs,
+    generatedMetadataPaths: generatedMetadataPaths,
+    mfTypesArchive: mfTypesArchive,
+    moduleFederationConfigFile: moduleFederationConfigFile,
+    skippedScanDirs: skippedScanDirs
+});
+exports.defaultAppRootDirs = __webpack_exports__.defaultAppRootDirs;
+exports.generatedMetadataPaths = __webpack_exports__.generatedMetadataPaths;
+exports.mfTypesArchive = __webpack_exports__.mfTypesArchive;
+exports.moduleFederationConfigFile = __webpack_exports__.moduleFederationConfigFile;
+exports.skippedScanDirs = __webpack_exports__.skippedScanDirs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defaultAppRootDirs",
+    "generatedMetadataPaths",
+    "mfTypesArchive",
+    "moduleFederationConfigFile",
+    "skippedScanDirs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/mf-validation/discovery.cjs

@@ -0,0 +1,77 @@
+"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__, {
+    discoverModuleFederationConfigs: ()=>discoverModuleFederationConfigs
+});
+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_constants_cjs_namespaceObject = require("./constants.cjs");
+const external_path_utils_cjs_namespaceObject = require("./path-utils.cjs");
+function discoverModuleFederationConfigs(options) {
+    const workspaceRoot = external_node_path_default().resolve(options.workspaceRoot);
+    const appDirs = new Set();
+    if (options.appDirs && options.appDirs.length > 0) for (const appDir of options.appDirs)appDirs.add((0, external_path_utils_cjs_namespaceObject.normalizeRelativePath)(appDir));
+    else {
+        const metadata = (0, external_path_utils_cjs_namespaceObject.readGeneratedMetadata)(workspaceRoot);
+        const scanRoots = new Set(external_constants_cjs_namespaceObject.defaultAppRootDirs);
+        for (const metadataEntry of metadata){
+            (0, external_path_utils_cjs_namespaceObject.collectMetadataAppDirs)(metadataEntry, appDirs);
+            (0, external_path_utils_cjs_namespaceObject.collectBridgeScanRoots)(metadataEntry, scanRoots);
+        }
+        for (const appDir of appDirs){
+            const segment = (0, external_path_utils_cjs_namespaceObject.firstSegment)(appDir);
+            if (segment) scanRoots.add(segment);
+        }
+        if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, external_constants_cjs_namespaceObject.moduleFederationConfigFile))) appDirs.add('.');
+        for (const scanRoot of scanRoots)(0, external_path_utils_cjs_namespaceObject.scanForModuleFederationConfigs)(workspaceRoot, scanRoot, appDirs);
+    }
+    return Array.from(appDirs).sort().map((appDir)=>({
+            appDir,
+            configPath: external_node_path_default().join(workspaceRoot, appDir, external_constants_cjs_namespaceObject.moduleFederationConfigFile)
+        }));
+}
+exports.discoverModuleFederationConfigs = __webpack_exports__.discoverModuleFederationConfigs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "discoverModuleFederationConfigs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/mf-validation/inspect.cjs

@@ -0,0 +1,84 @@
+"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_cjs_namespaceObject = require("./object-literal.cjs");
+const external_syntax_cjs_namespaceObject = require("./syntax.cjs");
+function extractExposes(configPath, value) {
+    if (void 0 === value) return [];
+    const object = (0, external_object_literal_cjs_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.`);
+        return Array.from(object.properties.keys()).sort();
+    }
+    const array = (0, external_object_literal_cjs_namespaceObject.parseArrayLiteral)(value);
+    if (array) return 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) {
+    if (void 0 === value) return {};
+    const dts = (0, external_object_literal_cjs_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_cjs_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_cjs_namespaceObject.parseLiteralString)(compilerInstanceSource) ?? ('tsgoCompilerInstance' === compilerInstanceSource ? 'effect-tsgo' : void 0),
+        tsConfigPath: (0, external_object_literal_cjs_namespaceObject.parseLiteralString)(dts.properties.get('tsConfigPath'))
+    };
+}
+function hasHostOnlyNoExposesDeclaration(source) {
+    return /@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(source);
+}
+function inspectModuleFederationConfigSource(source, appDir, configPath) {
+    const configObject = (0, external_syntax_cjs_namespaceObject.findCreateModuleFederationConfigObject)(source) ?? (0, external_syntax_cjs_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_cjs_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 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,
+        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/ultramodern-workspace/mf-validation/object-literal.cjs

@@ -0,0 +1,188 @@
+"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_cjs_namespaceObject = require("./syntax.cjs");
+function splitTopLevelEntries(source) {
+    const entries = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = (0, external_syntax_cjs_namespaceObject.skipSyntax)(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (',' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) {
+            const entry = source.slice(start, index).trim();
+            if (entry) entries.push(entry);
+            start = index + 1;
+        }
+    }
+    const finalEntry = source.slice(start).trim();
+    if (finalEntry) entries.push(finalEntry);
+    return entries;
+}
+function findTopLevelColon(source) {
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = (0, external_syntax_cjs_namespaceObject.skipSyntax)(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (':' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) return index;
+    }
+    return -1;
+}
+function stripConstAssertion(source) {
+    return source.trim().replace(/\s+as\s+const\s*$/u, '').trim();
+}
+function unescapeSingleQuotedString(value) {
+    return value.replace(/\\(['"\\nrtbfv0])/gu, (_, sequence)=>{
+        switch(sequence){
+            case 'n':
+                return '\n';
+            case 'r':
+                return '\r';
+            case 't':
+                return '\t';
+            case 'b':
+                return '\b';
+            case 'f':
+                return '\f';
+            case 'v':
+                return '\v';
+            case '0':
+                return '\0';
+            default:
+                return sequence;
+        }
+    });
+}
+function parseLiteralString(source) {
+    if (void 0 === source) return;
+    const trimmed = stripConstAssertion(source);
+    const quote = trimmed[0];
+    if ("'" !== quote && '"' !== quote && '`' !== quote) return;
+    if ('`' === quote) {
+        if (trimmed.includes('${')) return;
+        const close = trimmed.lastIndexOf('`');
+        return close > 0 ? trimmed.slice(1, close).replaceAll('\\`', '`') : void 0;
+    }
+    const close = trimmed.lastIndexOf(quote);
+    if (close <= 0 || '' !== trimmed.slice(close + 1).trim()) return;
+    const content = trimmed.slice(1, close);
+    if ('"' === quote) try {
+        return JSON.parse(trimmed);
+    } catch  {
+        return;
+    }
+    return unescapeSingleQuotedString(content);
+}
+function parseObjectKey(source) {
+    const trimmed = source.trim();
+    const literal = parseLiteralString(trimmed);
+    if (void 0 !== literal) return literal;
+    return /^[$A-Z_a-z][$\w]*$/u.test(trimmed) ? trimmed : void 0;
+}
+function parseObjectLiteral(source) {
+    if (void 0 === source) return;
+    const block = (0, external_syntax_cjs_namespaceObject.getOuterBlock)(source, '{', '}');
+    if (!block) return;
+    const properties = new Map();
+    let hasSpread = false;
+    for (const entry of splitTopLevelEntries(block.inner)){
+        if (entry.startsWith('...')) {
+            hasSpread = true;
+            continue;
+        }
+        const colon = findTopLevelColon(entry);
+        if (-1 === colon) {
+            hasSpread = true;
+            continue;
+        }
+        const key = parseObjectKey(entry.slice(0, colon));
+        if (void 0 === key) {
+            hasSpread = true;
+            continue;
+        }
+        properties.set(key, entry.slice(colon + 1).trim());
+    }
+    return {
+        hasSpread,
+        properties
+    };
+}
+function parseArrayLiteral(source) {
+    if (void 0 === source) return;
+    const block = (0, external_syntax_cjs_namespaceObject.getOuterBlock)(source, '[', ']');
+    if (!block) return;
+    const entries = splitTopLevelEntries(block.inner);
+    const exposes = [];
+    for (const entry of entries){
+        const expose = parseLiteralString(entry);
+        if (void 0 === expose) return;
+        exposes.push(expose);
+    }
+    return exposes;
+}
+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
+});

package/dist/cjs/ultramodern-workspace/mf-validation/path-utils.cjs

@@ -0,0 +1,165 @@
+"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__, {
+    collectBridgeScanRoots: ()=>collectBridgeScanRoots,
+    collectMetadataAppDirs: ()=>collectMetadataAppDirs,
+    firstSegment: ()=>firstSegment,
+    isRecord: ()=>isRecord,
+    normalizeRelativePath: ()=>normalizeRelativePath,
+    readGeneratedMetadata: ()=>readGeneratedMetadata,
+    readJsonIfExists: ()=>readJsonIfExists,
+    relativePath: ()=>relativePath,
+    scanForModuleFederationConfigs: ()=>scanForModuleFederationConfigs,
+    toPosixPath: ()=>toPosixPath
+});
+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_constants_cjs_namespaceObject = require("./constants.cjs");
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function toPosixPath(value) {
+    return value.split(external_node_path_default().sep).join('/');
+}
+function normalizeRelativePath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\.\/+/u, '');
+    const trimmed = normalized.replace(/\/+$/u, '');
+    return '' === trimmed ? '.' : trimmed;
+}
+function relativePath(root, target) {
+    return normalizeRelativePath(toPosixPath(external_node_path_default().relative(root, target)));
+}
+function readJsonIfExists(filePath) {
+    if (!external_node_fs_default().existsSync(filePath)) return;
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function addMetadataAppDir(value, appDirs, hint = '') {
+    if (!isRecord(value)) return;
+    const pathValue = 'string' == typeof value.path ? value.path : 'string' == typeof value.directory ? value.directory : void 0;
+    const hasModuleFederationDeclaration = isRecord(value.moduleFederation) || 'string' == typeof value.moduleFederationName || 'apps' === hint || 'verticals' === hint || 'remotes' === hint || 'moduleFederation' === hint;
+    if (pathValue && hasModuleFederationDeclaration && !external_node_path_default().isAbsolute(pathValue)) appDirs.add(normalizeRelativePath(pathValue));
+}
+function collectMetadataAppDirs(value, appDirs, hint = '') {
+    if (Array.isArray(value)) {
+        for (const entry of value)collectMetadataAppDirs(entry, appDirs, hint);
+        return;
+    }
+    if (!isRecord(value)) return;
+    addMetadataAppDir(value, appDirs, hint);
+    for (const [key, entry] of Object.entries(value))collectMetadataAppDirs(entry, appDirs, key);
+}
+function literalRootFromPattern(pattern) {
+    const normalized = normalizeRelativePath(pattern);
+    if ('.' === normalized || external_node_path_default().isAbsolute(normalized) || normalized.startsWith('../')) return;
+    const segments = normalized.split('/');
+    const literalSegments = [];
+    for (const segment of segments){
+        if (/[*?[\]{}]/u.test(segment)) break;
+        literalSegments.push(segment);
+    }
+    return literalSegments.length > 0 ? literalSegments.join('/') : void 0;
+}
+function collectBridgeScanRoots(value, roots) {
+    if (Array.isArray(value)) {
+        for (const entry of value)collectBridgeScanRoots(entry, roots);
+        return;
+    }
+    if (!isRecord(value)) return;
+    const workspacePackages = value.bridge;
+    if (isRecord(workspacePackages)) {
+        const entries = workspacePackages.workspacePackages;
+        if (Array.isArray(entries)) {
+            for (const entry of entries)if (isRecord(entry) && 'string' == typeof entry.pattern) {
+                const root = literalRootFromPattern(entry.pattern);
+                if (root) roots.add(root);
+            }
+        }
+    }
+    for (const entry of Object.values(value))collectBridgeScanRoots(entry, roots);
+}
+function readGeneratedMetadata(workspaceRoot) {
+    return external_constants_cjs_namespaceObject.generatedMetadataPaths.map((metadataPath)=>readJsonIfExists(external_node_path_default().join(workspaceRoot, metadataPath))).filter((metadata)=>void 0 !== metadata);
+}
+function firstSegment(appDir) {
+    if ('.' === appDir) return;
+    return appDir.split('/')[0];
+}
+function scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs) {
+    const absoluteRoot = external_node_path_default().join(workspaceRoot, scanRoot);
+    if (!external_node_fs_default().existsSync(absoluteRoot) || !external_node_fs_default().statSync(absoluteRoot).isDirectory()) return;
+    const visit = (directory)=>{
+        for (const entry of external_node_fs_default().readdirSync(directory, {
+            withFileTypes: true
+        })){
+            if (entry.isDirectory()) {
+                if (!external_constants_cjs_namespaceObject.skippedScanDirs.has(entry.name)) visit(external_node_path_default().join(directory, entry.name));
+                continue;
+            }
+            if (entry.isFile() && entry.name === external_constants_cjs_namespaceObject.moduleFederationConfigFile) appDirs.add(relativePath(workspaceRoot, directory));
+        }
+    };
+    visit(absoluteRoot);
+}
+exports.collectBridgeScanRoots = __webpack_exports__.collectBridgeScanRoots;
+exports.collectMetadataAppDirs = __webpack_exports__.collectMetadataAppDirs;
+exports.firstSegment = __webpack_exports__.firstSegment;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.normalizeRelativePath = __webpack_exports__.normalizeRelativePath;
+exports.readGeneratedMetadata = __webpack_exports__.readGeneratedMetadata;
+exports.readJsonIfExists = __webpack_exports__.readJsonIfExists;
+exports.relativePath = __webpack_exports__.relativePath;
+exports.scanForModuleFederationConfigs = __webpack_exports__.scanForModuleFederationConfigs;
+exports.toPosixPath = __webpack_exports__.toPosixPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectBridgeScanRoots",
+    "collectMetadataAppDirs",
+    "firstSegment",
+    "isRecord",
+    "normalizeRelativePath",
+    "readGeneratedMetadata",
+    "readJsonIfExists",
+    "relativePath",
+    "scanForModuleFederationConfigs",
+    "toPosixPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});