@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

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

@@ -0,0 +1,89 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { generatedMetadataPaths, moduleFederationConfigFile, skippedScanDirs } from "./constants.js";
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function toPosixPath(value) {
+    return value.split(node_path.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(node_path.relative(root, target)));
+}
+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;
+    }
+    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 || node_path.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 generatedMetadataPaths.map((metadataPath)=>readJsonIfExists(node_path.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 = node_path.join(workspaceRoot, scanRoot);
+    if (!node_fs.existsSync(absoluteRoot) || !node_fs.statSync(absoluteRoot).isDirectory()) return;
+    const visit = (directory)=>{
+        for (const entry of node_fs.readdirSync(directory, {
+            withFileTypes: true
+        })){
+            if (entry.isDirectory()) {
+                if (!skippedScanDirs.has(entry.name)) visit(node_path.join(directory, entry.name));
+                continue;
+            }
+            if (entry.isFile() && entry.name === moduleFederationConfigFile) appDirs.add(relativePath(workspaceRoot, directory));
+        }
+    };
+    visit(absoluteRoot);
+}
+export { addMetadataAppDir, collectBridgeScanRoots, collectMetadataAppDirs, firstSegment, isRecord, literalRootFromPattern, normalizeRelativePath, readGeneratedMetadata, readJsonIfExists, relativePath, scanForModuleFederationConfigs, toPosixPath };

package/dist/esm/ultramodern-workspace/mf-validation/syntax.js

@@ -0,0 +1,154 @@
+function isEscaped(source, index) {
+    let slashCount = 0;
+    for(let cursor = index - 1; cursor >= 0 && '\\' === source[cursor]; cursor -= 1)slashCount += 1;
+    return slashCount % 2 === 1;
+}
+function skipQuoted(source, start, quote) {
+    for(let index = start + 1; index < source.length; index += 1)if (source[index] === quote && !isEscaped(source, index)) return index + 1;
+    return source.length;
+}
+function skipLineComment(source, start) {
+    const newline = source.indexOf('\n', start + 2);
+    return -1 === newline ? source.length : newline + 1;
+}
+function skipBlockComment(source, start) {
+    const close = source.indexOf('*/', start + 2);
+    return -1 === close ? source.length : close + 2;
+}
+function skipTemplateExpression(source, start) {
+    let depth = 1;
+    for(let index = start + 1; index < source.length; index += 1){
+        const char = source[index];
+        const next = source[index + 1];
+        if ("'" === char) {
+            index = skipQuoted(source, index, "'") - 1;
+            continue;
+        }
+        if ('"' === char) {
+            index = skipQuoted(source, index, '"') - 1;
+            continue;
+        }
+        if ('`' === char) {
+            index = skipTemplate(source, index) - 1;
+            continue;
+        }
+        if ('/' === char && '/' === next) {
+            index = skipLineComment(source, index) - 1;
+            continue;
+        }
+        if ('/' === char && '*' === next) {
+            index = skipBlockComment(source, index) - 1;
+            continue;
+        }
+        if ('{' === char) {
+            depth += 1;
+            continue;
+        }
+        if ('}' === char) {
+            depth -= 1;
+            if (0 === depth) return index + 1;
+        }
+    }
+    return source.length;
+}
+function skipTemplate(source, start) {
+    for(let index = start + 1; index < source.length; index += 1){
+        const char = source[index];
+        const next = source[index + 1];
+        if ('`' === char && !isEscaped(source, index)) return index + 1;
+        if ('$' === char && '{' === next && !isEscaped(source, index)) index = skipTemplateExpression(source, index + 1) - 1;
+    }
+    return source.length;
+}
+function skipSyntax(source, index) {
+    const char = source[index];
+    const next = source[index + 1];
+    if ("'" === char) return skipQuoted(source, index, "'");
+    if ('"' === char) return skipQuoted(source, index, '"');
+    if ('`' === char) return skipTemplate(source, index);
+    if ('/' === char && '/' === next) return skipLineComment(source, index);
+    if ('/' === char && '*' === next) return skipBlockComment(source, index);
+    return index;
+}
+function findBalanced(source, start, open, close) {
+    let depth = 1;
+    for(let index = start + 1; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        if (source[index] === open) {
+            depth += 1;
+            continue;
+        }
+        if (source[index] === close) {
+            depth -= 1;
+            if (0 === depth) return index;
+        }
+    }
+}
+function skipWhitespaceAndComments(source, start) {
+    let index = start;
+    while(index < source.length){
+        const char = source[index];
+        const next = source[index + 1];
+        if (/\s/u.test(char ?? '')) {
+            index += 1;
+            continue;
+        }
+        if ('/' === char && '/' === next) {
+            index = skipLineComment(source, index);
+            continue;
+        }
+        if ('/' === char && '*' === next) {
+            index = skipBlockComment(source, index);
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function hasIdentifierBoundary(source, start, end) {
+    return !/[$\w]/u.test(source[start - 1] ?? '') && !/[$\w]/u.test(source[end] ?? '');
+}
+function findCreateModuleFederationConfigObject(source) {
+    const callee = 'createModuleFederationConfig';
+    let offset = 0;
+    while(offset < source.length){
+        const index = source.indexOf(callee, offset);
+        if (-1 === index) break;
+        offset = index + callee.length;
+        if (!hasIdentifierBoundary(source, index, offset)) continue;
+        const parenIndex = skipWhitespaceAndComments(source, offset);
+        if ('(' !== source[parenIndex]) continue;
+        const argumentIndex = skipWhitespaceAndComments(source, parenIndex + 1);
+        if ('{' !== source[argumentIndex]) throw new Error('Module Federation config must pass a static object literal to createModuleFederationConfig.');
+        const closeIndex = findBalanced(source, argumentIndex, '{', '}');
+        if (void 0 === closeIndex) throw new Error('Module Federation config object literal is not closed.');
+        return source.slice(argumentIndex, closeIndex + 1);
+    }
+}
+function findExportDefaultObject(source) {
+    const exportDefault = 'export default';
+    const index = source.indexOf(exportDefault);
+    if (-1 === index) return;
+    const objectStart = skipWhitespaceAndComments(source, index + exportDefault.length);
+    if ('{' !== source[objectStart]) return;
+    const objectEnd = findBalanced(source, objectStart, '{', '}');
+    if (void 0 === objectEnd) throw new Error('Module Federation export default object is not closed.');
+    return source.slice(objectStart, objectEnd + 1);
+}
+function getOuterBlock(source, open, close) {
+    const trimmed = source.trim();
+    if (trimmed[0] !== open) return;
+    const end = findBalanced(trimmed, 0, open, close);
+    if (void 0 === end) return;
+    const suffix = trimmed.slice(end + 1).trim();
+    if ('' !== suffix && !suffix.startsWith('as ') && !suffix.startsWith('satisfies ')) return;
+    return {
+        inner: trimmed.slice(1, end),
+        suffix
+    };
+}
+export { findBalanced, findCreateModuleFederationConfigObject, findExportDefaultObject, getOuterBlock, hasIdentifierBoundary, isEscaped, skipBlockComment, skipLineComment, skipQuoted, skipSyntax, skipTemplate, skipTemplateExpression, skipWhitespaceAndComments };

package/dist/esm/ultramodern-workspace/mf-validation/validate.js

@@ -0,0 +1,57 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { mfTypesArchive } from "./constants.js";
+import { discoverModuleFederationConfigs } from "./discovery.js";
+import { inspectModuleFederationConfigSource } from "./inspect.js";
+import { relativePath } from "./path-utils.js";
+function assertExposedAppDtsSettings(app) {
+    if ('tsgo' !== app.dts.compilerInstance) throw new Error(`Module Federation DTS compilerInstance must be "tsgo" for ${app.appDir}.`);
+    if ('./tsconfig.mf-types.json' !== app.dts.tsConfigPath) throw new Error(`Module Federation DTS tsConfigPath must be "./tsconfig.mf-types.json" for ${app.appDir}.`);
+}
+function assertTypesArchive(workspaceRoot, appDir) {
+    const typesArchivePath = node_path.join(workspaceRoot, appDir, mfTypesArchive);
+    if (!node_fs.existsSync(typesArchivePath)) throw new Error(`Missing Module Federation DTS archive: ${relativePath(workspaceRoot, typesArchivePath)}`);
+    if (0 === node_fs.statSync(typesArchivePath).size) throw new Error(`Empty Module Federation DTS archive: ${relativePath(workspaceRoot, typesArchivePath)}`);
+}
+function validateModuleFederationTypes(options) {
+    const workspaceRoot = node_path.resolve(options.workspaceRoot);
+    const discoveredConfigs = discoverModuleFederationConfigs({
+        ...options,
+        workspaceRoot
+    });
+    const apps = [];
+    const missingConfigPaths = [];
+    for (const discoveredConfig of discoveredConfigs){
+        if (!node_fs.existsSync(discoveredConfig.configPath)) {
+            missingConfigPaths.push(relativePath(workspaceRoot, discoveredConfig.configPath));
+            continue;
+        }
+        const configPath = relativePath(workspaceRoot, discoveredConfig.configPath);
+        apps.push(inspectModuleFederationConfigSource(node_fs.readFileSync(discoveredConfig.configPath, 'utf-8'), discoveredConfig.appDir, configPath));
+    }
+    if (missingConfigPaths.length > 0) throw new Error(`Missing Module Federation config: ${missingConfigPaths.join(', ')}`);
+    const noExposeApps = apps.filter((app)=>0 === app.exposes.length && !app.hostOnlyNoExposes);
+    if (noExposeApps.length > 0) {
+        const suffix = 0 === apps.filter((app)=>app.exposes.length > 0).length ? ' Validation would otherwise validate zero exposed apps.' : '';
+        throw new Error(`Module Federation configs declare no exposes without an explicit host-only/no-exposes declaration: ${noExposeApps.map((app)=>app.appDir).join(', ')}.${suffix}`);
+    }
+    let exposedAppCount = 0;
+    let hostOnlyAppCount = 0;
+    for (const app of apps){
+        if (app.hostOnlyNoExposes) {
+            hostOnlyAppCount += 1;
+            continue;
+        }
+        assertExposedAppDtsSettings(app);
+        assertTypesArchive(workspaceRoot, app.appDir);
+        exposedAppCount += 1;
+    }
+    if (apps.length > 0 && 0 === exposedAppCount && hostOnlyAppCount !== apps.length) throw new Error('Module Federation validation inspected configs but validated zero exposed apps. Declare host-only/no-exposes intent only for host apps without exposes.');
+    return {
+        apps,
+        configCount: apps.length,
+        exposedAppCount,
+        hostOnlyAppCount
+    };
+}
+export { assertExposedAppDtsSettings, assertTypesArchive, validateModuleFederationTypes };