@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/cjs/ultramodern-workspace/overlay-baseline-guard.cjs

@@ -0,0 +1,408 @@
+"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__, {
+    BASELINE_DEPENDENCY_PINS: ()=>BASELINE_DEPENDENCY_PINS,
+    OverlayBaselineRelaxationError: ()=>OverlayBaselineRelaxationError,
+    assertOverlayPreservedBaseline: ()=>assertOverlayPreservedBaseline,
+    captureOverlayBaselineSnapshot: ()=>captureOverlayBaselineSnapshot
+});
+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 utils_namespaceObject = require("@modern-js/utils");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const BASELINE_DEPENDENCY_PINS = Object.freeze({
+    react: external_versions_cjs_namespaceObject.REACT_VERSION,
+    'react-dom': external_versions_cjs_namespaceObject.REACT_DOM_VERSION,
+    '@tanstack/react-router': external_versions_cjs_namespaceObject.TANSTACK_ROUTER_VERSION,
+    '@tanstack/router-core': external_versions_cjs_namespaceObject.TANSTACK_ROUTER_CORE_VERSION,
+    effect: external_versions_cjs_namespaceObject.EFFECT_VERSION,
+    tailwindcss: external_versions_cjs_namespaceObject.TAILWIND_VERSION
+});
+const FORBIDDEN_SHELL_ARTIFACT_SEGMENTS = [
+    'api',
+    'server',
+    'backend-federation.config.ts'
+];
+const IGNORED_WALK_DIRECTORIES = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'dist-cloudflare',
+    'node_modules'
+]);
+class OverlayBaselineRelaxationError extends Error {
+    constructor(generator, violations){
+        super([
+            `UltraModern CodeSmith overlay relaxed the Platform Baseline: ${generator}`,
+            ...violations.map((violation)=>`  - ${violation.path}: ${violation.detail}`)
+        ].join('\n')), this.code = 'ULTRAMODERN_OVERLAY_BASELINE_RELAXATION';
+        this.name = 'OverlayBaselineRelaxationError';
+        this.generator = generator;
+        this.violations = violations;
+    }
+}
+function walkFiles(root, predicate) {
+    const matches = [];
+    const queue = [
+        root
+    ];
+    while(queue.length > 0){
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = external_node_fs_default().readdirSync(current, {
+                withFileTypes: true
+            });
+        } catch  {
+            continue;
+        }
+        for (const entry of entries){
+            const absolute = external_node_path_default().join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_WALK_DIRECTORIES.has(entry.name)) queue.push(absolute);
+                continue;
+            }
+            const relative = external_node_path_default().relative(root, absolute).split(external_node_path_default().sep).join('/');
+            if (predicate(relative)) matches.push(relative);
+        }
+    }
+    return matches.sort();
+}
+function isPackageManifest(relativePath) {
+    return 'package.json' === relativePath || relativePath.endsWith('/package.json');
+}
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+];
+function readPackageJson(workspaceRoot, packageJsonRelativePath) {
+    const parsed = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().join(workspaceRoot, packageJsonRelativePath), 'utf-8'));
+    return (0, external_types_cjs_namespaceObject.isRecord)(parsed) ? parsed : {};
+}
+function dependencyEntries(parsed) {
+    const entries = [];
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if ((0, external_types_cjs_namespaceObject.isRecord)(group)) {
+            for (const [name, value] of Object.entries(group))if ('string' == typeof value) entries.push({
+                section,
+                name,
+                value
+            });
+        }
+    }
+    return entries;
+}
+function baselineDependencyFromKey(key) {
+    const candidate = key.trim().split('>').at(-1) ?? '';
+    return Object.keys(BASELINE_DEPENDENCY_PINS).find((dependency)=>candidate === dependency || candidate.startsWith(`${dependency}@`));
+}
+function collectPolicyEntries(value, prefix, entries) {
+    if (!(0, external_types_cjs_namespaceObject.isRecord)(value)) return;
+    for (const [key, child] of Object.entries(value)){
+        const childPath = '' === prefix ? key : `${prefix}.${key}`;
+        const dependency = baselineDependencyFromKey(key);
+        if (void 0 !== dependency && 'string' == typeof child) entries.push({
+            path: childPath,
+            dependency,
+            value: child
+        });
+        if ((0, external_types_cjs_namespaceObject.isRecord)(child)) collectPolicyEntries(child, childPath, entries);
+    }
+}
+function policyRoots(parsed) {
+    const pnpm = (0, external_types_cjs_namespaceObject.isRecord)(parsed.pnpm) ? parsed.pnpm : void 0;
+    return [
+        [
+            'overrides',
+            parsed.overrides
+        ],
+        [
+            'resolutions',
+            parsed.resolutions
+        ],
+        [
+            'pnpm.overrides',
+            pnpm?.overrides
+        ],
+        [
+            'catalog',
+            parsed.catalog
+        ],
+        [
+            'catalogs',
+            parsed.catalogs
+        ],
+        [
+            'pnpm.catalog',
+            pnpm?.catalog
+        ],
+        [
+            'pnpm.catalogs',
+            pnpm?.catalogs
+        ]
+    ];
+}
+function baselinePolicyEntries(parsed) {
+    const entries = [];
+    for (const [prefix, value] of policyRoots(parsed))if (void 0 !== value) collectPolicyEntries(value, prefix, entries);
+    return entries;
+}
+function readPnpmWorkspaceYaml(workspaceRoot) {
+    try {
+        const parsed = utils_namespaceObject.yaml.load(external_node_fs_default().readFileSync(external_node_path_default().join(workspaceRoot, 'pnpm-workspace.yaml'), 'utf-8'));
+        return (0, external_types_cjs_namespaceObject.isRecord)(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+}
+function collectCatalogValues(parsed) {
+    const values = new Map();
+    const collect = (value, prefix)=>{
+        if (!(0, external_types_cjs_namespaceObject.isRecord)(value)) return;
+        for (const [key, child] of Object.entries(value)){
+            const childPath = '' === prefix ? key : `${prefix}.${key}`;
+            if ('string' == typeof child) {
+                values.set(key, child);
+                values.set(childPath, child);
+            } else collect(child, childPath);
+        }
+    };
+    for (const [prefix, value] of policyRoots(parsed).filter(([prefix])=>/catalog/u.test(prefix)))collect(value ?? {}, prefix);
+    return values;
+}
+function resolveCatalogReference(value, catalogValues) {
+    if (!value.startsWith('catalog:')) return value;
+    return catalogValues.get(value.slice(8)) ?? value;
+}
+function parseNpmAlias(value) {
+    if (!value.startsWith('npm:')) return;
+    const target = value.slice(4);
+    const separator = target.startsWith('@') ? target.indexOf('@', 1) : target.indexOf('@');
+    if (-1 === separator) return {
+        name: target,
+        range: void 0
+    };
+    return {
+        name: target.slice(0, separator),
+        range: target.slice(separator + 1)
+    };
+}
+function baselineSpecMatches(value, dependency) {
+    const expected = BASELINE_DEPENDENCY_PINS[dependency];
+    if (value === expected) return true;
+    const alias = parseNpmAlias(value);
+    return alias?.name === dependency && alias.range === expected;
+}
+function baselinePinsFromParsed(parsed) {
+    const pins = {};
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if ((0, external_types_cjs_namespaceObject.isRecord)(group)) for (const dependency of Object.keys(BASELINE_DEPENDENCY_PINS)){
+            const value = group[dependency];
+            if ('string' == typeof value) pins[`${section}.${dependency}`] = value;
+        }
+    }
+    return pins;
+}
+function readBaselinePins(workspaceRoot, packageJsonRelativePath) {
+    return baselinePinsFromParsed(readPackageJson(workspaceRoot, packageJsonRelativePath));
+}
+function captureOverlayBaselineSnapshot(workspaceRoot, shellPackageDirectories) {
+    const baselinePinsByManifest = {};
+    const baselinePolicyPinsByManifest = {};
+    for (const manifest of walkFiles(workspaceRoot, isPackageManifest)){
+        const parsed = readPackageJson(workspaceRoot, manifest);
+        baselinePinsByManifest[manifest] = readBaselinePins(workspaceRoot, manifest);
+        baselinePolicyPinsByManifest[manifest] = Object.fromEntries(baselinePolicyEntries(parsed).map((entry)=>[
+                entry.path,
+                entry.value
+            ]));
+    }
+    const shellFiles = new Set();
+    for (const shellDir of shellPackageDirectories){
+        const absolute = external_node_path_default().join(workspaceRoot, shellDir);
+        if (external_node_fs_default().existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true))shellFiles.add(`${shellDir}/${file}`);
+    }
+    return {
+        baselinePinsByManifest,
+        baselinePolicyPinsByManifest,
+        baselineWorkspacePolicyPins: Object.fromEntries(baselinePolicyEntries(readPnpmWorkspaceYaml(workspaceRoot)).map((entry)=>[
+                entry.path,
+                entry.value
+            ])),
+        shellPackageDirectories,
+        shellFiles
+    };
+}
+function collectPolicyViolations(parsed, beforePolicyPins, displayPath) {
+    const violations = [];
+    const currentPolicyEntries = baselinePolicyEntries(parsed);
+    const currentPolicyPins = Object.fromEntries(currentPolicyEntries.map((entry)=>[
+            entry.path,
+            entry.value
+        ]));
+    for (const [policyPath, previous] of Object.entries(beforePolicyPins)){
+        if (Object.hasOwn(currentPolicyPins, policyPath)) continue;
+        const dependency = baselineDependencyFromKey(policyPath.split('.').at(-1) ?? '') ?? policyPath.split('.').at(-1) ?? policyPath;
+        const expected = BASELINE_DEPENDENCY_PINS[dependency];
+        if (void 0 !== expected) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${policyPath}`,
+            detail: `overlay removed baseline policy "${policyPath}" from "${previous}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    const catalogValues = collectCatalogValues(parsed);
+    for (const entry of currentPolicyEntries){
+        const resolvedVersion = resolveCatalogReference(entry.value, catalogValues);
+        const expected = BASELINE_DEPENDENCY_PINS[entry.dependency];
+        if (!baselineSpecMatches(resolvedVersion, entry.dependency)) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${entry.path}`,
+            detail: `overlay policy "${entry.path}" pins baseline dependency "${entry.dependency}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    return violations;
+}
+function collectVersionViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    const manifests = new Set([
+        ...walkFiles(workspaceRoot, isPackageManifest),
+        ...Object.keys(snapshot.baselinePinsByManifest)
+    ]);
+    for (const manifest of manifests){
+        let parsed;
+        try {
+            parsed = readPackageJson(workspaceRoot, manifest);
+        } catch  {
+            parsed = {};
+        }
+        const pins = baselinePinsFromParsed(parsed);
+        const before = snapshot.baselinePinsByManifest[manifest] ?? {};
+        for (const key of Object.keys(before)){
+            if (Object.hasOwn(pins, key)) continue;
+            const separator = key.indexOf('.');
+            const section = key.slice(0, separator);
+            const dependency = key.slice(separator + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay removed baseline dependency "${dependency}" from ${section}; Platform Baseline pin is "${expected}"`
+            });
+        }
+        const catalogValues = collectCatalogValues(parsed);
+        for (const [key, version] of Object.entries(pins)){
+            const dependency = key.slice(key.indexOf('.') + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            const previous = before[key];
+            const resolvedVersion = resolveCatalogReference(version, catalogValues);
+            const matches = baselineSpecMatches(resolvedVersion, dependency);
+            if (void 0 !== previous || matches) {
+                if (void 0 !== previous && version !== previous && !matches) violations.push({
+                    kind: 'baseline-version-relaxation',
+                    path: manifest,
+                    detail: `overlay changed baseline dependency "${dependency}" from "${previous}" to "${version}"; Platform Baseline pin is "${expected}"`
+                });
+            } else violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay added baseline dependency "${dependency}" at "${version}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        for (const entry of dependencyEntries(parsed)){
+            const alias = parseNpmAlias(entry.value);
+            if (void 0 === alias) continue;
+            const expected = BASELINE_DEPENDENCY_PINS[alias.name];
+            if (void 0 !== expected && alias.range !== expected) violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay alias "${entry.name}" resolves to baseline dependency "${alias.name}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        violations.push(...collectPolicyViolations(parsed, snapshot.baselinePolicyPinsByManifest?.[manifest] ?? {}, manifest));
+    }
+    violations.push(...collectPolicyViolations(readPnpmWorkspaceYaml(workspaceRoot), snapshot.baselineWorkspacePolicyPins ?? {}, 'pnpm-workspace.yaml'));
+    return violations;
+}
+function collectForbiddenShellArtifactViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    for (const shellDir of snapshot.shellPackageDirectories){
+        const absolute = external_node_path_default().join(workspaceRoot, shellDir);
+        if (external_node_fs_default().existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true)){
+            const relative = `${shellDir}/${file}`;
+            if (snapshot.shellFiles.has(relative)) continue;
+            const segments = file.split('/');
+            const forbidden = FORBIDDEN_SHELL_ARTIFACT_SEGMENTS.find((segment)=>segments.includes(segment) || file === segment);
+            if (forbidden) violations.push({
+                kind: 'forbidden-shell-artifact',
+                path: relative,
+                detail: `overlay introduced a forbidden thin-shell artifact class "${forbidden}" into shell package ${shellDir}`
+            });
+        }
+    }
+    return violations;
+}
+function assertOverlayPreservedBaseline(options) {
+    const violations = [
+        ...collectVersionViolations(options.workspaceRoot, options.snapshot),
+        ...collectForbiddenShellArtifactViolations(options.workspaceRoot, options.snapshot)
+    ];
+    if (violations.length > 0) throw new OverlayBaselineRelaxationError(options.generator, violations);
+}
+exports.BASELINE_DEPENDENCY_PINS = __webpack_exports__.BASELINE_DEPENDENCY_PINS;
+exports.OverlayBaselineRelaxationError = __webpack_exports__.OverlayBaselineRelaxationError;
+exports.assertOverlayPreservedBaseline = __webpack_exports__.assertOverlayPreservedBaseline;
+exports.captureOverlayBaselineSnapshot = __webpack_exports__.captureOverlayBaselineSnapshot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BASELINE_DEPENDENCY_PINS",
+    "OverlayBaselineRelaxationError",
+    "assertOverlayPreservedBaseline",
+    "captureOverlayBaselineSnapshot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -3,6 +3,15 @@ const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 }();
 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)=>{
@@ -34,8 +43,25 @@ __webpack_require__.d(__webpack_exports__, {
     runCodeSmithOverlays: ()=>runCodeSmithOverlays
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_overlay_baseline_guard_cjs_namespaceObject = require("./overlay-baseline-guard.cjs");
 const overlays_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function resolveShellPackageDirectories(workspaceRoot) {
+    const appsRoot = external_node_path_default().join(workspaceRoot, 'apps');
+    let entries;
+    try {
+        entries = external_node_fs_default().readdirSync(appsRoot, {
+            withFileTypes: true
+        });
+    } catch  {
+        return [];
+    }
+    return entries.filter((entry)=>entry.isDirectory()).map((entry)=>`apps/${entry.name}`).sort();
+}
 const overlayRunnerSource = `
 const fs = require('node:fs');
 
@@ -59,11 +85,19 @@ const fs = require('node:fs');
 `;
 function runCodeSmithOverlays(options) {
     if (!options.overlays?.length) return;
-    for (const overlay of options.overlays)runCodeSmithOverlay({
-        workspaceRoot: options.workspaceRoot,
-        overlay,
-        config: createOverlayRuntimeConfig(options.workspaceRoot, options.result)
-    });
+    const snapshot = (0, external_overlay_baseline_guard_cjs_namespaceObject.captureOverlayBaselineSnapshot)(options.workspaceRoot, resolveShellPackageDirectories(options.workspaceRoot));
+    for (const overlay of options.overlays){
+        runCodeSmithOverlay({
+            workspaceRoot: options.workspaceRoot,
+            overlay,
+            config: createOverlayRuntimeConfig(options.workspaceRoot, options.result)
+        });
+        (0, external_overlay_baseline_guard_cjs_namespaceObject.assertOverlayPreservedBaseline)({
+            workspaceRoot: options.workspaceRoot,
+            generator: overlay.generator,
+            snapshot
+        });
+    }
 }
 function runCodeSmithOverlay(options) {
     const result = (0, external_node_child_process_namespaceObject.spawnSync)(process.execPath, [