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

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

@@ -0,0 +1,92 @@
+"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__, {
+    extractDtsSettings: ()=>extractDtsSettings,
+    extractExposes: ()=>extractExposes,
+    hasHostOnlyNoExposesDeclaration: ()=>hasHostOnlyNoExposesDeclaration,
+    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.`);
+    return {
+        compilerInstance: (0, external_object_literal_cjs_namespaceObject.parseLiteralString)(generateTypes?.properties.get('compilerInstance')),
+        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.extractDtsSettings = __webpack_exports__.extractDtsSettings;
+exports.extractExposes = __webpack_exports__.extractExposes;
+exports.hasHostOnlyNoExposesDeclaration = __webpack_exports__.hasHostOnlyNoExposesDeclaration;
+exports.inspectModuleFederationConfigSource = __webpack_exports__.inspectModuleFederationConfigSource;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractDtsSettings",
+    "extractExposes",
+    "hasHostOnlyNoExposesDeclaration",
+    "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,203 @@
+"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__, {
+    findTopLevelColon: ()=>findTopLevelColon,
+    parseArrayLiteral: ()=>parseArrayLiteral,
+    parseLiteralString: ()=>parseLiteralString,
+    parseObjectKey: ()=>parseObjectKey,
+    parseObjectLiteral: ()=>parseObjectLiteral,
+    splitTopLevelEntries: ()=>splitTopLevelEntries,
+    stripConstAssertion: ()=>stripConstAssertion,
+    unescapeSingleQuotedString: ()=>unescapeSingleQuotedString
+});
+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.findTopLevelColon = __webpack_exports__.findTopLevelColon;
+exports.parseArrayLiteral = __webpack_exports__.parseArrayLiteral;
+exports.parseLiteralString = __webpack_exports__.parseLiteralString;
+exports.parseObjectKey = __webpack_exports__.parseObjectKey;
+exports.parseObjectLiteral = __webpack_exports__.parseObjectLiteral;
+exports.splitTopLevelEntries = __webpack_exports__.splitTopLevelEntries;
+exports.stripConstAssertion = __webpack_exports__.stripConstAssertion;
+exports.unescapeSingleQuotedString = __webpack_exports__.unescapeSingleQuotedString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findTopLevelColon",
+    "parseArrayLiteral",
+    "parseLiteralString",
+    "parseObjectKey",
+    "parseObjectLiteral",
+    "splitTopLevelEntries",
+    "stripConstAssertion",
+    "unescapeSingleQuotedString"
+].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,171 @@
+"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__, {
+    addMetadataAppDir: ()=>addMetadataAppDir,
+    collectBridgeScanRoots: ()=>collectBridgeScanRoots,
+    collectMetadataAppDirs: ()=>collectMetadataAppDirs,
+    firstSegment: ()=>firstSegment,
+    isRecord: ()=>isRecord,
+    literalRootFromPattern: ()=>literalRootFromPattern,
+    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.addMetadataAppDir = __webpack_exports__.addMetadataAppDir;
+exports.collectBridgeScanRoots = __webpack_exports__.collectBridgeScanRoots;
+exports.collectMetadataAppDirs = __webpack_exports__.collectMetadataAppDirs;
+exports.firstSegment = __webpack_exports__.firstSegment;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.literalRootFromPattern = __webpack_exports__.literalRootFromPattern;
+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 === [
+    "addMetadataAppDir",
+    "collectBridgeScanRoots",
+    "collectMetadataAppDirs",
+    "firstSegment",
+    "isRecord",
+    "literalRootFromPattern",
+    "normalizeRelativePath",
+    "readGeneratedMetadata",
+    "readJsonIfExists",
+    "relativePath",
+    "scanForModuleFederationConfigs",
+    "toPosixPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});