@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm-node/ultramodern-workspace/generation-result.js

@@ -4,8 +4,8 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 import { rpcPath } from "./api/rpc.js";
 import { createDeliveryUnitRecord } from "./delivery-unit.js";
-import { apiSurface, exposeSurface } from "./delivery-unit-schema/up-projection.js";
-import { ULTRAMODERN_CONFIG_PATH, appHasApi, resolveApiProtocol } from "./descriptors.js";
+import { apiSurface, exposeSurface } from "./delivery-unit-schema/surfaces.js";
+import { appHasApi, resolveApiProtocol } from "./descriptors.js";
 import { normalizePath, packageName } from "./naming.js";
 import { resolveOwnerAttribution } from "./types.js";
 import { EFFECT_VERSION, REACT_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_VERSION } from "./versions.js";
@@ -78,7 +78,7 @@ function createGenerationResult(options) {
                 app.id,
                 app.apiPrefix
             ])),
-        generatedContractPath: ULTRAMODERN_CONFIG_PATH,
+        generatedContractPath: 'topology/reference-topology.json',
         warnings: options.warnings ?? [],
         deliveryUnits: options.createdApps.map((app)=>createGeneratedDeliveryUnitDescriptor(options.packageScope, app))
     };

package/dist/esm-node/ultramodern-workspace/index.js

@@ -4,5 +4,5 @@ export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.
 export { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
 export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError } from "./overlay-baseline-guard.js";
 export { SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES } from "./shared-patches.js";
-export { PRIMARY_SHELL_ID, createShellDescriptor, resolveConfiguredAdditionalShells } from "./shells.js";
+export { PRIMARY_SHELL_ID, createShellDescriptor } from "./shells.js";
 export { generateUltramodernWorkspace } from "./write-workspace.js";

package/dist/esm-node/ultramodern-workspace/mf-validation/constants.js

@@ -4,9 +4,6 @@ const mfTypesArchives = {
     cloudflare: 'dist-cloudflare/@mf-types.zip',
     node: 'dist/@mf-types.zip'
 };
-const generatedMetadataPaths = [
-    '.modernjs/ultramodern.json'
-];
 const defaultAppRootDirs = [
     'apps',
     'verticals'
@@ -20,4 +17,4 @@ const skippedScanDirs = new Set([
     'dist',
     'node_modules'
 ]);
-export { defaultAppRootDirs, generatedMetadataPaths, mfTypesArchives, moduleFederationConfigFile, skippedScanDirs };
+export { defaultAppRootDirs, mfTypesArchives, moduleFederationConfigFile, skippedScanDirs };

package/dist/esm-node/ultramodern-workspace/mf-validation/discovery.js

@@ -2,18 +2,18 @@ import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
 import { defaultAppRootDirs, moduleFederationConfigFile } from "./constants.js";
-import { collectBridgeScanRoots, collectMetadataAppDirs, firstSegment, normalizeRelativePath, readGeneratedMetadata, scanForModuleFederationConfigs } from "./path-utils.js";
+import { collectMetadataAppDirs, collectWorkspaceScanRoots, firstSegment, normalizeRelativePath, readJsonIfExists, scanForModuleFederationConfigs } from "./path-utils.js";
 function discoverModuleFederationConfigs(options) {
     const workspaceRoot = node_path.resolve(options.workspaceRoot);
     const appDirs = new Set();
+    const metadata = readJsonIfExists(node_path.join(workspaceRoot, 'topology/reference-topology.json'));
+    const metadataAppDirs = new Set();
+    const apiOnlyDirs = collectMetadataAppDirs(metadata, metadataAppDirs);
     if (options.appDirs && options.appDirs.length > 0) for (const appDir of options.appDirs)appDirs.add(normalizeRelativePath(appDir));
     else {
-        const metadata = readGeneratedMetadata(workspaceRoot);
         const scanRoots = new Set(defaultAppRootDirs);
-        for (const metadataEntry of metadata){
-            collectMetadataAppDirs(metadataEntry, appDirs);
-            collectBridgeScanRoots(metadataEntry, scanRoots);
-        }
+        for (const appDir of metadataAppDirs)appDirs.add(appDir);
+        collectWorkspaceScanRoots(workspaceRoot, scanRoots);
         for (const appDir of appDirs){
             const segment = firstSegment(appDir);
             if (segment) scanRoots.add(segment);
@@ -21,7 +21,7 @@ function discoverModuleFederationConfigs(options) {
         if (node_fs.existsSync(node_path.join(workspaceRoot, moduleFederationConfigFile))) appDirs.add('.');
         for (const scanRoot of scanRoots)scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs);
     }
-    return Array.from(appDirs).sort().map((appDir)=>({
+    return Array.from(appDirs).sort().filter((appDir)=>!apiOnlyDirs.has(appDir) || node_fs.existsSync(node_path.join(workspaceRoot, appDir, moduleFederationConfigFile))).map((appDir)=>({
             appDir,
             configPath: node_path.join(workspaceRoot, appDir, moduleFederationConfigFile)
         }));

package/dist/esm-node/ultramodern-workspace/mf-validation/exposes.js

@@ -0,0 +1,15 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { moduleFederationConfigFile } from "./constants.js";
+import { inspectModuleFederationConfigSource } from "./inspect.js";
+function readModuleFederationExposePaths(workspaceRoot, appDirectory) {
+    const configPath = node_path.join(workspaceRoot, appDirectory, moduleFederationConfigFile);
+    if (!node_fs.existsSync(configPath)) return;
+    try {
+        return inspectModuleFederationConfigSource(node_fs.readFileSync(configPath, 'utf-8'), appDirectory, node_path.join(appDirectory, moduleFederationConfigFile)).exposePaths;
+    } catch  {
+        return;
+    }
+}
+export { readModuleFederationExposePaths };

package/dist/esm-node/ultramodern-workspace/mf-validation/inspect.js

@@ -1,18 +1,36 @@
 import "node:module";
 import { parseArrayLiteral, parseLiteralString, parseObjectLiteral } from "./object-literal.js";
-import { findCreateModuleFederationConfigObject, findExportDefaultObject } from "./syntax.js";
+import { findCreateModuleFederationConfigObject, findExportDefaultObject, parseConfigModule } from "./syntax.js";
 function extractExposes(configPath, value) {
-    if (void 0 === value) return [];
+    if (void 0 === value) return {
+        exposePaths: {},
+        exposes: []
+    };
     const object = 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 exposePaths = {};
+        for (const [expose, source] of object.properties){
+            const exposePath = parseLiteralString(source);
+            if (void 0 !== exposePath) exposePaths[expose] = exposePath;
+        }
+        return {
+            exposePaths,
+            exposes: Array.from(object.properties.keys()).sort()
+        };
     }
     const array = parseArrayLiteral(value);
-    if (array) return array.sort();
+    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) {
+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 = parseObjectLiteral(value);
     if (!dts || dts.hasSpread) throw new Error(`Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`);
@@ -25,7 +43,7 @@ function extractDtsSettings(configPath, value) {
     };
 }
 function hasHostOnlyNoExposesDeclaration(source) {
-    return /@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(source);
+    return (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 = findCreateModuleFederationConfigObject(source) ?? findExportDefaultObject(source);
@@ -33,13 +51,14 @@ function inspectModuleFederationConfigSource(source, appDir, configPath) {
     const properties = 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 { 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')),
+        dts: extractDtsSettings(configPath, properties.properties.get('dts'), exposes),
+        exposePaths,
         exposes,
         hostOnlyNoExposes
     };

package/dist/esm-node/ultramodern-workspace/mf-validation/object-literal.js

@@ -1,128 +1,28 @@
 import "node:module";
-import { getOuterBlock, skipSyntax } from "./syntax.js";
-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 = 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 = 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;
-        }
-    });
-}
+import { parseStaticExpression } from "./syntax.js";
 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;
+    const node = 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) {
-    if (void 0 === source) return;
-    const block = getOuterBlock(source, '{', '}');
-    if (!block) return;
+    const node = parseStaticExpression(source);
+    if (void 0 === source || node?.type !== 'ObjectExpression') 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) {
+    for (const property of node.properties){
+        if ('ObjectProperty' !== property.type || property.computed || property.shorthand) {
             hasSpread = true;
             continue;
         }
-        const key = parseObjectKey(entry.slice(0, colon));
-        if (void 0 === key) {
+        const key = 'Identifier' === property.key.type ? property.key.name : 'StringLiteral' === property.key.type ? property.key.value : void 0;
+        const value = 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;
         }
-        properties.set(key, entry.slice(colon + 1).trim());
+        const rawValue = source.slice(property.value.start ?? 0, property.value.end ?? 0);
+        properties.set(key, rawValue.slice(value.start, value.end));
     }
     return {
         hasSpread,
@@ -130,16 +30,15 @@ function parseObjectLiteral(source) {
     };
 }
 function parseArrayLiteral(source) {
-    if (void 0 === source) return;
-    const block = 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);
+    const node = 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 exposes;
+    return values;
 }
 export { parseArrayLiteral, parseLiteralString, parseObjectLiteral };

package/dist/esm-node/ultramodern-workspace/mf-validation/path-utils.js

@@ -1,7 +1,8 @@
 import "node:module";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { generatedMetadataPaths, moduleFederationConfigFile, skippedScanDirs } from "./constants.js";
+import { yaml } from "@modern-js/utils";
+import { moduleFederationConfigFile, skippedScanDirs } from "./constants.js";
 function isRecord(value) {
     return null !== value && 'object' == typeof value && !Array.isArray(value);
 }
@@ -20,20 +21,31 @@ function readJsonIfExists(filePath) {
     if (!node_fs.existsSync(filePath)) return;
     return JSON.parse(node_fs.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 && !node_path.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;
+function collectMetadataAppDirs(value, appDirs) {
+    const apiOnlyDirs = new Set();
+    if (!isRecord(value)) return apiOnlyDirs;
+    const entries = [
+        {
+            app: value.shell,
+            vertical: false
+        },
+        ...Array.isArray(value.verticals) ? value.verticals.map((app)=>({
+                app,
+                vertical: true
+            })) : [],
+        ...Array.isArray(value.shells) ? value.shells.map((app)=>({
+                app,
+                vertical: false
+            })) : []
+    ];
+    for (const { app: entry, vertical } of entries){
+        if (!isRecord(entry) || 'string' != typeof entry.path || node_path.isAbsolute(entry.path)) throw new Error('Reference topology apps require relative paths.');
+        const normalized = normalizeRelativePath(entry.path);
+        if ('..' === normalized || normalized.startsWith('../')) throw new Error(`Topology app path leaves workspace: ${entry.path}`);
+        if (vertical && 'api-only' === entry.surfaceProfile) apiOnlyDirs.add(normalized);
+        else appDirs.add(normalized);
     }
-    if (!isRecord(value)) return;
-    addMetadataAppDir(value, appDirs, hint);
-    for (const [key, entry] of Object.entries(value))collectMetadataAppDirs(entry, appDirs, key);
+    return apiOnlyDirs;
 }
 function literalRootFromPattern(pattern) {
     const normalized = normalizeRelativePath(pattern);
@@ -46,26 +58,16 @@ function literalRootFromPattern(pattern) {
     }
     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;
+function collectWorkspaceScanRoots(workspaceRoot, roots) {
+    const file = node_path.join(workspaceRoot, 'pnpm-workspace.yaml');
+    if (!node_fs.existsSync(file)) return;
+    const workspace = yaml.load(node_fs.readFileSync(file, 'utf8'));
+    if (!isRecord(workspace) || !Array.isArray(workspace.packages)) return;
+    for (const pattern of workspace.packages){
+        if ('string' != typeof pattern || pattern.startsWith('!')) continue;
+        const root = literalRootFromPattern(pattern);
+        if (root) roots.add(root);
     }
-    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 generatedMetadataPaths.map((metadataPath)=>readJsonIfExists(node_path.join(workspaceRoot, metadataPath))).filter((metadata)=>void 0 !== metadata);
 }
 function firstSegment(appDir) {
     if ('.' === appDir) return;
@@ -87,4 +89,4 @@ function scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs) {
     };
     visit(absoluteRoot);
 }
-export { collectBridgeScanRoots, collectMetadataAppDirs, firstSegment, isRecord, normalizeRelativePath, readGeneratedMetadata, readJsonIfExists, relativePath, scanForModuleFederationConfigs, toPosixPath };
+export { collectMetadataAppDirs, collectWorkspaceScanRoots, firstSegment, isRecord, normalizeRelativePath, readJsonIfExists, relativePath, scanForModuleFederationConfigs, toPosixPath };