@bleedingdev/modern-js-create 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/dist/esm-node/ultramodern-workspace/module-federation.js

@@ -0,0 +1,416 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import { appHasEffectApi, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, effectApiPrefix, remoteDependencyAlias, resolveRemoteRefs, shellApp } from "./descriptors.js";
+import { createRspackChunkLoadingGlobal, createRspackUniqueName, packageName } from "./naming.js";
+import { createCloudflareSecurityContract, formatTsJsonValue } from "./policy.js";
+import { sortJsonValue } from "./types.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE } from "./versions.js";
+function createAppModernConfig(scope, app) {
+    const bffImport = appHasEffectApi(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
+    const bffConfig = appHasEffectApi(app) ? `      bff: {
+        effect: {
+          entry: './api/effect/index',
+          openapi: {
+            path: '/openapi.json',
+          },
+        },
+        prefix: '${effectApiPrefix(app)}',
+        runtimeFramework: 'effect',
+      },
+` : '';
+    const bffPluginEntry = appHasEffectApi(app) ? '        bffPlugin(),\n' : '';
+    return `// @effect-diagnostics processEnv:off
+import {
+  appTools,
+  defineConfig,
+  presetUltramodern,
+} from '@modern-js/app-tools';
+${bffImport}import { i18nPlugin } from '@modern-js/plugin-i18n';
+import { tanstackRouterPlugin } from '@modern-js/plugin-tanstack';
+import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+import { withZephyr as withZephyrRspack } from 'zephyr-rspack-plugin';
+import { ultramodernLocalisedUrls } from './src/routes/ultramodern-route-metadata';
+
+type ZephyrRspackConfig = Parameters<ReturnType<typeof withZephyrRspack>>[0];
+
+const zephyrEnabled = process.env['ULTRAMODERN_ZEPHYR'] !== 'false';
+const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+
+const zephyrRspackPlugin = () => ({
+  name: 'ultramodern-zephyr-rspack-plugin',
+  pre: ['@modern-js/plugin-module-federation-config'],
+  setup(api: {
+    modifyRspackConfig: (
+      handler: (
+        config: ZephyrRspackConfig,
+      ) => ZephyrRspackConfig | Promise<ZephyrRspackConfig>,
+    ) => void;
+  }) {
+    if (!zephyrEnabled) {
+      return;
+    }
+    api.modifyRspackConfig(config => withZephyrRspack()(config));
+  },
+});
+
+const appId = '${app.id}';
+const cloudflareWorkerName = '${createCloudflareWorkerName(scope, app)}';
+const port = Number(process.env['${app.portEnv}'] ?? ${app.port});
+const envValue = (name: string) => {
+  const value = process.env[name]?.trim();
+  return value !== undefined && value.length > 0 ? value : undefined;
+};
+const configuredSiteUrl = envValue('MODERN_PUBLIC_SITE_URL');
+const configuredCloudflareUrl = envValue('${createCloudflarePublicUrlEnv(app)}');
+const configuredUltramodernAssetPrefix = envValue('ULTRAMODERN_ASSET_PREFIX');
+const configuredModernAssetPrefix = envValue('MODERN_ASSET_PREFIX');
+const cloudflareWorkersDevSubdomain = envValue(
+  'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+);
+const inferredCloudflareUrl =
+  cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined
+    ? \`https://\${cloudflareWorkerName}.\${cloudflareWorkersDevSubdomain}.workers.dev\`
+    : undefined;
+// Site origin (SEO: canonical/hreflang URLs) prefers the site-wide public URL;
+// the per-app deployment URL only fills in when no site origin is configured.
+const siteUrl =
+  configuredSiteUrl ||
+  configuredCloudflareUrl ||
+  inferredCloudflareUrl ||
+  \`http://localhost:\${port}\`;
+// Asset loading is intentionally independent from the canonical site URL and
+// deployment public URL. Without an explicit asset prefix, assets stay
+// origin-relative so self-hosted apps, tunnels, and reverse proxies never leak
+// localhost URLs into production HTML.
+const assetPrefix =
+  configuredModernAssetPrefix || configuredUltramodernAssetPrefix || '/';
+
+if (
+  cloudflareDeployEnabled &&
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true' &&
+  configuredCloudflareUrl === undefined &&
+  configuredSiteUrl === undefined &&
+  inferredCloudflareUrl === undefined
+) {
+  throw new Error(
+    \`Cloudflare deploy for \${appId} needs ${createCloudflarePublicUrlEnv(app)}, MODERN_PUBLIC_SITE_URL, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN.\`,
+  );
+}
+
+export default defineConfig(
+  presetUltramodern(
+    {
+${bffConfig}      ...(cloudflareDeployEnabled
+        ? {
+            deploy: {
+              worker: {
+                compatibilityDate: '${CLOUDFLARE_COMPATIBILITY_DATE}',
+                name: cloudflareWorkerName,
+                security: ${formatTsJsonValue(sortJsonValue(createCloudflareSecurityContract()), 16)},
+                ssr: true,
+              },
+            },
+          }
+        : {}),
+      dev: {
+        // Keep dev assets origin-relative too; the default absolute
+        // http://localhost:<port> prefix breaks pages served through tunnels.
+        assetPrefix: '/',
+      },
+      html: {
+        outputStructure: 'flat',
+      },
+      output: {
+        assetPrefix,
+        disableTsChecker: true,
+        distPath: {
+          html: './',
+        },
+        polyfill: 'off',
+        splitRouteChunks: true,
+      },
+      performance: {
+        rsdoctor: {
+          disableClientServer: true,
+          enabled: process.env['ULTRAMODERN_RSDOCTOR'] === 'true',
+        },
+      },
+      plugins: [
+        appTools(),
+        tanstackRouterPlugin(),
+        i18nPlugin({
+          backend: {
+            enabled: true,
+            loadPath: '/locales/{{lng}}/{{ns}}.json',
+          },
+          localeDetection: {
+            fallbackLanguage: 'en',
+            ignoreRedirectRoutes: [
+              '/@mf-types',
+              '/assets',
+              '/bundles',
+              '${effectApiPrefix(app)}',
+              '/locales',
+              '/mf-manifest.json',
+              '/mf-stats.json',
+              '/remoteEntry.js',
+              '/robots.txt',
+              '/site.webmanifest',
+              '/sitemap.xml',
+              '/static',
+              '/zephyr-manifest.json',
+            ],
+            languages: ['en', 'cs'],
+            localePathRedirect: true,
+            localisedUrls: ultramodernLocalisedUrls as Record<string, Record<string, string>>,
+          },
+          reactI18next: false,
+        }),
+${bffPluginEntry}        moduleFederationPlugin(),
+        zephyrRspackPlugin(),
+      ],
+      server: {
+        port,
+        publicDir: ['./locales', './assets'],
+        ssr: {
+          mode: 'string',
+          moduleFederationAppSSR: true,
+        },
+      },
+      source: {
+        globalVars: {
+          ULTRAMODERN_SITE_URL: siteUrl,
+        },
+        mainEntryName: 'index',
+      },
+      tools: {
+        autoprefixer: {
+          overrideBrowserslist: ['defaults'],
+        },
+        bundlerChain: chain => {
+          chain.output
+            .uniqueName('${createRspackUniqueName(app)}')
+            .chunkLoadingGlobal('${createRspackChunkLoadingGlobal(app)}');
+          chain.ignoreWarnings([
+            {
+              message: /the request of a dependency is an expression/u,
+              module: /modern-js-plugin-i18n/u,
+            },
+          ]);
+        },
+      },
+    },
+    {
+      appId,
+      enableBffRequestId: true,
+      enableModuleFederationSSR: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+    },
+  ),
+);
+`;
+}
+function createSharedModuleFederationConfig() {
+    return `  shared: {
+    '@modern-js/plugin-i18n/runtime': {
+      requiredVersion: pluginI18nVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/plugin-tanstack/runtime': {
+      requiredVersion: pluginTanstackVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/runtime': {
+      requiredVersion: runtimeVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@tanstack/react-router': {
+      requiredVersion: dependencies['@tanstack/react-router'],
+      singleton: true,
+      treeShaking: false,
+    },
+    react: {
+      requiredVersion: reactVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom/client': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+  }`;
+}
+function formatTsObjectLiteral(value) {
+    const entries = Object.entries(value).sort(([left], [right])=>left.localeCompare(right));
+    if (0 === entries.length) return '{}';
+    return `{
+${entries.map(([key, entryValue])=>`    '${key}': '${entryValue}',`).join('\n')}
+  }`;
+}
+function createModuleFederationRemoteUrlHelpers(app, remotes = []) {
+    if (0 === resolveRemoteRefs(app, remotes).length) return '';
+    return `const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+const cloudflareWorkersDevSubdomain =
+  process.env['ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN']?.trim();
+const requireCloudflarePublicUrls =
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true';
+
+const createRemoteManifestUrl = (options: {
+  manifestEnv: string;
+  mfName: string;
+  port: number;
+  publicUrlEnv: string;
+  workerName: string;
+}) => {
+  const configuredManifest = process.env[options.manifestEnv]?.trim();
+  if (configuredManifest !== undefined && configuredManifest.length > 0) {
+    return configuredManifest;
+  }
+
+  const configuredPublicUrl = process.env[options.publicUrlEnv]?.trim();
+  if (configuredPublicUrl !== undefined && configuredPublicUrl.length > 0) {
+    return \`\${options.mfName}@\${configuredPublicUrl.replace(/\\/+$/u, '')}/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined) {
+    return \`\${options.mfName}@https://\${options.workerName}.\${cloudflareWorkersDevSubdomain}.workers.dev/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && requireCloudflarePublicUrls) {
+    throw new Error(
+      \`Cloudflare deploy needs \${options.publicUrlEnv}, \${options.manifestEnv}, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN for remote \${options.mfName}.\`,
+    );
+  }
+
+  return \`\${options.mfName}@http://localhost:\${options.port}/mf-manifest.json\`;
+};
+
+`;
+}
+function createModuleFederationRemotesConfig(scope, app, remotes = []) {
+    const remoteEntries = resolveRemoteRefs(app, remotes).toSorted((left, right)=>remoteDependencyAlias(left).localeCompare(remoteDependencyAlias(right))).map((remote)=>{
+        const key = remoteDependencyAlias(remote);
+        return `    ${key}: createRemoteManifestUrl({
+      manifestEnv: '${createRemoteManifestEnv(remote)}',
+      mfName: '${remote.mfName}',
+      port: ${remote.port},
+      publicUrlEnv: '${createCloudflarePublicUrlEnv(remote)}',
+      workerName: '${createCloudflareWorkerName(scope, remote)}',
+    }),`;
+    }).join('\n');
+    if (!remoteEntries) return '';
+    return `  remotes: {
+${remoteEntries}
+  },
+`;
+}
+function createShellModuleFederationConfig(scope, remotes = []) {
+    const shellHost = {
+        ...shellApp,
+        verticalRefs: remotes.map((remote)=>remote.id)
+    };
+    return `// @effect-diagnostics nodeBuiltinImport:off processEnv:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(shellHost, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  filename: 'remoteEntry.js',
+  name: '${shellApp.mfName}',
+${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+function createBuildMarker(scope, app) {
+    return node_crypto.createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createUltramodernBuildModule(scope, app) {
+    return `export const ultramodernVerticalIdentity = {
+  appId: '${app.id}',
+  build: '${createBuildMarker(scope, app)}',
+  deployProfile: 'cloudflare-ssr-mf-effect-v1',
+  packageName: '${packageName(scope, app.packageSuffix)}',
+  version: '0.1.0',
+} as const;
+
+export const ultramodernUiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'ui',
+} as const;
+
+export const ultramodernApiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'effect-bff',
+} as const;
+`;
+}
+function createRemoteModuleFederationConfig(scope, app, remotes = []) {
+    const exposes = formatTsObjectLiteral(app.exposes ?? {});
+    return `// @effect-diagnostics nodeBuiltinImport:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(app, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  exposes: ${exposes},
+  filename: 'remoteEntry.js',
+  name: '${app.mfName}',
+${createModuleFederationRemotesConfig(scope, app, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+export { createAppModernConfig, createBuildMarker, createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig, createRemoteModuleFederationConfig, createSharedModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, formatTsObjectLiteral };

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

@@ -0,0 +1,72 @@
+import "node:module";
+import node_path from "node:path";
+const TAILWIND_PREFIX_DIGIT_WORDS = [
+    'zero',
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine'
+];
+function normalizePath(filePath) {
+    return filePath.split(node_path.sep).join('/');
+}
+function toPackageScope(packageName) {
+    const normalized = packageName.replace(/^@/, '').replace(/[\\/]+/g, '-').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '').replace(/-{2,}/g, '-');
+    return normalized || 'ultramodern-superapp';
+}
+function toKebabCase(value) {
+    const normalized = value.trim().replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/[._]+/g, '-').toLowerCase().replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized;
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return `${pascal.charAt(0).toLowerCase()}${pascal.slice(1)}`;
+}
+function toEnvSegment(value) {
+    return toKebabCase(value).replace(/-/g, '_').toUpperCase();
+}
+function createRspackUniqueName(app) {
+    return app.mfName;
+}
+function createRspackChunkLoadingGlobal(app) {
+    return `__ULTRAMODERN_${toEnvSegment(app.mfName)}_LOADED_CHUNKS__`;
+}
+function naming_packageName(scope, suffix) {
+    return `@${scope}/${suffix}`;
+}
+function relativeRootFor(packageDir) {
+    return normalizePath(node_path.relative(packageDir, '.') || '.');
+}
+function createTailwindPrefix(raw) {
+    const normalized = raw.toLowerCase().replace(/[^a-z0-9]/gu, '');
+    if (!normalized) throw new Error(`Cannot derive a Tailwind prefix from ${raw}`);
+    return normalized.replace(/[0-9]/gu, (digit)=>TAILWIND_PREFIX_DIGIT_WORDS[Number(digit)]);
+}
+function tailwindPrefixForApp(app) {
+    if ('shell' === app.kind) return 'shell';
+    return createTailwindPrefix(app.domain ?? app.id);
+}
+function assertUniqueTailwindPrefixes(apps) {
+    const seen = new Map();
+    const entries = apps.map((app)=>[
+            app.id,
+            tailwindPrefixForApp(app)
+        ]);
+    for (const [id, prefix] of entries){
+        const previous = seen.get(prefix);
+        if (previous) throw new Error(`Tailwind prefix ${prefix} for ${id} collides with ${previous}`);
+        seen.set(prefix, id);
+    }
+}
+function createTw(prefix) {
+    return (classList)=>classList.split(/\s+/u).filter(Boolean).map((candidate)=>`${prefix}:${candidate.replace(/\[&&\]:/gu, '')}`).join(' ');
+}
+function toPascalCase(value) {
+    return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+export { TAILWIND_PREFIX_DIGIT_WORDS, assertUniqueTailwindPrefixes, createRspackChunkLoadingGlobal, createRspackUniqueName, createTailwindPrefix, createTw, naming_packageName as packageName, normalizePath, relativeRootFor, tailwindPrefixForApp, toCamelCase, toEnvSegment, toKebabCase, toPackageScope, toPascalCase };

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

@@ -0,0 +1,80 @@
+import "node:module";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+const overlays_require = createRequire(import.meta.url);
+const overlayRunnerSource = `
+const fs = require('node:fs');
+
+(async () => {
+  const payload = JSON.parse(fs.readFileSync(0, 'utf-8'));
+  const { CodeSmith } = require(payload.codesmithModulePath);
+  const codesmith = new CodeSmith({});
+  await codesmith.forge({
+    pwd: payload.workspaceRoot,
+    tasks: [
+      {
+        generator: payload.generator,
+        config: payload.config,
+      },
+    ],
+  });
+})().catch(error => {
+  console.error(error?.stack || error?.message || String(error));
+  process.exit(1);
+});
+`;
+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)
+    });
+}
+function runCodeSmithOverlay(options) {
+    const result = spawnSync(process.execPath, [
+        '--eval',
+        overlayRunnerSource
+    ], {
+        cwd: options.workspaceRoot,
+        encoding: 'utf8',
+        input: JSON.stringify({
+            workspaceRoot: options.workspaceRoot,
+            generator: options.overlay.generator,
+            codesmithModulePath: overlays_require.resolve('@modern-js/codesmith'),
+            config: {
+                ...options.overlay.config ?? {},
+                ...options.config
+            }
+        })
+    });
+    if (0 !== result.status) {
+        const detail = [
+            result.stderr.trim(),
+            result.stdout.trim()
+        ].filter(Boolean).join('\n');
+        throw new Error([
+            `UltraModern CodeSmith overlay failed: ${options.overlay.generator}`,
+            detail
+        ].filter(Boolean).join('\n'));
+    }
+}
+function createOverlayRuntimeConfig(workspaceRoot, result) {
+    const generatedApp = result.createdApps[0];
+    return {
+        workspaceRoot,
+        packageScope: result.packageScope,
+        operation: result.operation,
+        generatedApp,
+        generatedApps: result.createdApps,
+        assignedPort: generatedApp ? result.assignedPorts[generatedApp.id] : void 0,
+        assignedPorts: result.assignedPorts,
+        moduleFederationName: generatedApp ? result.moduleFederationNames[generatedApp.id] : void 0,
+        moduleFederationNames: result.moduleFederationNames,
+        effectApiPrefix: generatedApp ? result.effectApiPrefixes[generatedApp.id] : void 0,
+        effectApiPrefixes: result.effectApiPrefixes,
+        packageSource: result.packageSource,
+        generationResult: result
+    };
+}
+export { runCodeSmithOverlays };