@bleedingdev/modern-js-create 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/esm/ultramodern-workspace/app-files.js

@@ -112,28 +112,13 @@ function createAppStyles(enableTailwind, scope, app) {
     return 'shell' === app.kind ? createShellStyles(enableTailwind, scope) : createRemoteStyles(enableTailwind, scope, app);
 }
 function createPostcssConfig() {
-    return `export default {
-  plugins: {
-    '@tailwindcss/postcss': {},
-  },
-};
-`;
+    return renderFileTemplate('workspace/postcss.config.mjs', {});
 }
 function createTailwindConfig() {
-    return `import type { Config } from 'tailwindcss';
-
-export default {} satisfies Config;
-`;
+    return renderFileTemplate('workspace/tailwind.config.ts', {});
 }
 function createSharedDesignTokensCss() {
-    return `@theme {
-  --color-um-accent: #2f8f68;
-  --color-um-canvas: #f1eadc;
-  --color-um-foreground: #133225;
-  --color-um-link: #166b4b;
-  --color-um-surface: #f6fbf7;
-}
-`;
+    return renderFileTemplate('workspace/packages/shared-design-tokens/tokens.css', {});
 }
 function createRouteHeadModule(app) {
     return renderFileTemplate('app/ultramodern-route-head.tsx', {

package/dist/esm/ultramodern-workspace/backend-federation.js

@@ -1,10 +1,9 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, formatBackendFederationValidationErrors, validateBackendFederationMetadata } from "@modern-js/utils/universal";
 import { verticalApiExport, verticalApiGroupName } from "./api.js";
 import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "./delivery-unit.js";
 import { appHasApi, createBackendFederationContainerEntry, createBackendFederationManifestEnv, createBackendFederationManifestUrl, createBackendFederationName, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, resolveApiPrefix, resolveApiStem } from "./descriptors.js";
 import { packageName, toEnvSegment } from "./naming.js";
 import { EFFECT_VERSION, MODULE_FEDERATION_VERSION } from "./versions.js";
-const BACKEND_FEDERATION_CONTRACT_VERSION = 'microvertical-server-effect-v1';
-const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = 'backend-mf-effect-v1';
 function createZephyrEnv(app, suffix) {
     return `ZEPHYR_${toEnvSegment(app.domain ?? app.id)}_${suffix}`;
 }
@@ -60,7 +59,7 @@ function createCloudflareExecutionSurface(scope, app) {
         }
     };
 }
-function createNodeExecutionSurface(app) {
+function createNodeExecutionSurface(app, deliveryUnit) {
     return {
         kind: 'node-mf-runtime',
         adapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
@@ -69,8 +68,14 @@ function createNodeExecutionSurface(app) {
         manifestUrl: createBackendFederationManifestUrl(app),
         containerEntry: createBackendFederationContainerEntry(app),
         remoteType: 'module',
-        expose: './effect-api',
-        runtimePackage: '@modern-js/plugin-bff/effect'
+        expose: BACKEND_FEDERATION_EFFECT_EXPOSE,
+        runtimePackage: '@modern-js/plugin-bff/effect',
+        ...deliveryUnit ? {
+            expected: {
+                unitId: deliveryUnit.unitId,
+                buildMarker: deliveryUnit.buildMarker
+            }
+        } : {}
     };
 }
 function createServerExecutionOverlay(scope, app) {
@@ -84,21 +89,21 @@ function createServerExecutionOverlay(scope, app) {
             buildMarker: deliveryUnit.buildMarker
         },
         cloudflare: createCloudflareExecutionSurface(scope, app),
-        node: createNodeExecutionSurface(app)
+        node: createNodeExecutionSurface(app, deliveryUnit)
     };
 }
 function createBackendFederationContract(scope, app) {
     if (!appHasApi(app)) return;
     const readiness = `${app.api.prefix}/${resolveApiStem(app)}/readiness`;
     const deliveryUnit = createDeliveryUnitRecord(scope, app);
-    return {
+    const contract = {
         role: 'microvertical-server',
         name: createBackendFederationName(app),
         runtimeFramework: 'effect',
         strictEffectApproach: true,
         deliveryUnit: deliveryUnitContractBlock(deliveryUnit),
         exposes: {
-            './effect-api': createEffectExpose(app)
+            [BACKEND_FEDERATION_EFFECT_EXPOSE]: createEffectExpose(app)
         },
         versionBoundary: {
             invariant: 'web-and-api-same-build',
@@ -117,7 +122,7 @@ function createBackendFederationContract(scope, app) {
         },
         executionSurfaces: {
             cloudflare: createCloudflareExecutionSurface(scope, app),
-            node: createNodeExecutionSurface(app)
+            node: createNodeExecutionSurface(app, deliveryUnit)
         },
         compatibility: {
             contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
@@ -137,6 +142,14 @@ function createBackendFederationContract(scope, app) {
             strategy: 'typed-effect-error'
         }
     };
+    const validation = validateBackendFederationMetadata(contract, {
+        path: `${app.id}.backendFederation`,
+        requireEffectExpose: true,
+        requireEffectRuntime: true,
+        requireVersionFields: true
+    });
+    if (!validation.ok) throw new Error(`Backend federation contract invalid for ${app.id}: ${formatBackendFederationValidationErrors(validation.errors)}.`);
+    return contract;
 }
 function createBackendFederationMetadata(scope, app) {
     if (!appHasApi(app)) return;
@@ -147,7 +160,7 @@ function createBackendFederationMetadata(scope, app) {
             'node-mf-runtime'
         ],
         exposes: [
-            './effect-api'
+            BACKEND_FEDERATION_EFFECT_EXPOSE
         ],
         name: createBackendFederationName(app),
         nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
@@ -182,7 +195,7 @@ export const backendFederationContract = {
   },
   contractVersion: '${BACKEND_FEDERATION_CONTRACT_VERSION}',
   executionSurfaces: ['node-mf-runtime'],
-  exposes: ['./effect-api'],
+  exposes: ['${BACKEND_FEDERATION_EFFECT_EXPOSE}'],
   name: '${createBackendFederationName(app)}',
   nodeAdapterVersion: '${BACKEND_FEDERATION_NODE_ADAPTER_VERSION}',
   openapiPath: '${app.api.prefix}/openapi.json',
@@ -199,6 +212,7 @@ export default runtime;
 }
 function createBackendFederationSummary(scope, app) {
     if (!appHasApi(app)) return;
+    const deliveryUnit = createDeliveryUnitRecord(scope, app);
     return {
         id: app.id,
         path: app.directory,
@@ -207,10 +221,10 @@ function createBackendFederationSummary(scope, app) {
         runtimeFramework: 'effect',
         strictEffectApproach: true,
         contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
-        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, app)),
+        deliveryUnit: deliveryUnitContractBlock(deliveryUnit),
         executionSurfaces: {
             cloudflare: createCloudflareExecutionSurface(scope, app),
-            node: createNodeExecutionSurface(app)
+            node: createNodeExecutionSurface(app, deliveryUnit)
         }
     };
 }

package/dist/esm/ultramodern-workspace/bridge-config/cli.js

@@ -0,0 +1,30 @@
+import { readBridgeGates } from "./gates.js";
+import { normalizeUltramodernBridgeConfig } from "./normalize.js";
+import { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags } from "./schema.js";
+import { parseLockfilePolicy, readCsvOptionValues, readSingleValue, rejectBooleanFlagValues, requireNonEmptyValue } from "./shared.js";
+import { readWorkspacePackages } from "./workspace-packages.js";
+function hasUltramodernBridgeCliOptions(args) {
+    return args.some((arg)=>[
+            ...ultramodernBridgeCliBooleanFlags,
+            ...ultramodernBridgeCliValueFlags
+        ].some((flag)=>arg === flag || arg.startsWith(`${flag}=`)));
+}
+function parseUltramodernBridgeCliOptions(args) {
+    rejectBooleanFlagValues(args);
+    if (!hasUltramodernBridgeCliOptions(args)) return;
+    const parentRoot = readSingleValue(args, ultramodernBridgeCliFlags.parentRoot);
+    const lockfilePolicy = readSingleValue(args, ultramodernBridgeCliFlags.lockfilePolicy) ?? 'nested';
+    const workspacePackages = readWorkspacePackages(args);
+    const gates = readBridgeGates(args);
+    const reactSingletons = readCsvOptionValues(args, ultramodernBridgeCliFlags.reactSingleton);
+    return normalizeUltramodernBridgeConfig({
+        enabled: true,
+        parentRoot: requireNonEmptyValue(parentRoot, ultramodernBridgeCliFlags.parentRoot),
+        workspacePackages,
+        dependencies: readCsvOptionValues(args, ultramodernBridgeCliFlags.dependency),
+        lockfilePolicy: parseLockfilePolicy(lockfilePolicy),
+        gates,
+        reactSingletons: reactSingletons.length > 0 ? reactSingletons : void 0
+    });
+}
+export { hasUltramodernBridgeCliOptions, parseUltramodernBridgeCliOptions };

package/dist/esm/ultramodern-workspace/bridge-config/defaults.js

@@ -0,0 +1,5 @@
+const defaultReactSingletons = [
+    'react',
+    'react-dom'
+];
+export { defaultReactSingletons };

package/dist/esm/ultramodern-workspace/bridge-config/gates.js

@@ -0,0 +1,52 @@
+import { ultramodernBridgeCliFlags } from "./schema.js";
+import { readRepeatedOptionValues, requireNonEmptyValue, splitAssignment } from "./shared.js";
+function readBridgeGates(args) {
+    const gates = new Map();
+    const getGate = (name)=>{
+        const normalizedName = requireNonEmptyValue(name, `${ultramodernBridgeCliFlags.gate} name`);
+        const existing = gates.get(normalizedName);
+        if (existing) return existing;
+        const draft = {
+            name: normalizedName
+        };
+        gates.set(normalizedName, draft);
+        return draft;
+    };
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.gate)){
+        const { left: name, right: command } = splitAssignment(value, ultramodernBridgeCliFlags.gate, '<name>=<command>');
+        getGate(name).command = requireNonEmptyValue(command, `${ultramodernBridgeCliFlags.gate} command`);
+    }
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.gateCwd)){
+        const { left: name, right: cwd } = splitAssignment(value, ultramodernBridgeCliFlags.gateCwd, '<name>=<cwd>');
+        getGate(name).cwd = requireNonEmptyValue(cwd, `${ultramodernBridgeCliFlags.gateCwd} cwd`);
+    }
+    const missingCommand = [
+        ...gates.values()
+    ].find((gate)=>!gate.command);
+    if (missingCommand) throw new Error(`${ultramodernBridgeCliFlags.gateCwd} references "${missingCommand.name}" without a matching ${ultramodernBridgeCliFlags.gate}.`);
+    return normalizeBridgeGates([
+        ...gates.values()
+    ].map((gate)=>({
+            name: gate.name,
+            command: gate.command,
+            cwd: gate.cwd
+        })));
+}
+function normalizeBridgeGates(gates) {
+    const normalized = new Map();
+    for (const [index, gate] of gates.entries()){
+        const label = `bridge.gates[${index}]`;
+        const name = requireNonEmptyValue(gate.name, `${label}.name`);
+        normalized.set(name, {
+            name,
+            command: requireNonEmptyValue(gate.command, `${label}.command`),
+            ...gate.cwd ? {
+                cwd: requireNonEmptyValue(gate.cwd, `${label}.cwd`)
+            } : {}
+        });
+    }
+    return [
+        ...normalized.values()
+    ];
+}
+export { normalizeBridgeGates, readBridgeGates };

package/dist/esm/ultramodern-workspace/bridge-config/index.js

@@ -0,0 +1,3 @@
+export { hasUltramodernBridgeCliOptions, parseUltramodernBridgeCliOptions } from "./cli.js";
+export { normalizeUltramodernBridgeConfig } from "./normalize.js";
+export { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies } from "./schema.js";

package/dist/esm/ultramodern-workspace/bridge-config/normalize.js

@@ -0,0 +1,30 @@
+import { defaultReactSingletons } from "./defaults.js";
+import { normalizeBridgeGates } from "./gates.js";
+import { parseLockfilePolicy, requireNonEmptyValue, uniqueNonEmptyValues } from "./shared.js";
+import { validateParentPackageCoverage, validateReactSingletons } from "./validation.js";
+import { normalizeWorkspacePackages } from "./workspace-packages.js";
+function normalizeUltramodernBridgeConfig(bridge) {
+    if (!bridge || false === bridge.enabled) return;
+    const parentRoot = requireNonEmptyValue(bridge.parentRoot, 'bridge.parentRoot');
+    const workspacePackages = normalizeWorkspacePackages(bridge.workspacePackages);
+    const dependencies = uniqueNonEmptyValues(bridge.dependencies, 'bridge.dependencies');
+    const gates = normalizeBridgeGates(bridge.gates);
+    const reactSingletons = bridge.reactSingletons && bridge.reactSingletons.length > 0 ? uniqueNonEmptyValues(bridge.reactSingletons, 'bridge.reactSingletons') : [
+        ...defaultReactSingletons
+    ];
+    if (0 === workspacePackages.length) throw new Error('Bridge mode requires at least one bridge.workspacePackages entry.');
+    if (0 === dependencies.length) throw new Error('Bridge mode requires at least one explicit bridge.dependencies package name.');
+    if (0 === gates.length) throw new Error('Bridge mode requires at least one bridge.gates delegated parent command.');
+    validateParentPackageCoverage(workspacePackages, dependencies);
+    validateReactSingletons(reactSingletons);
+    return {
+        enabled: true,
+        parentRoot,
+        workspacePackages,
+        dependencies,
+        lockfilePolicy: parseLockfilePolicy(bridge.lockfilePolicy ?? 'nested'),
+        gates,
+        reactSingletons
+    };
+}
+export { normalizeUltramodernBridgeConfig };

package/dist/esm/ultramodern-workspace/bridge-config/schema.js

@@ -0,0 +1,31 @@
+const ultramodernBridgeCliFlags = {
+    enabled: '--bridge',
+    parentRoot: '--bridge-parent-root',
+    workspacePackage: '--bridge-workspace-package',
+    workspacePackageName: '--bridge-workspace-package-name',
+    testAlias: '--bridge-test-alias',
+    dependency: '--bridge-dependency',
+    lockfilePolicy: '--bridge-lockfile-policy',
+    gate: '--bridge-gate',
+    gateCwd: '--bridge-gate-cwd',
+    reactSingleton: '--bridge-react-singleton'
+};
+const ultramodernBridgeCliValueFlags = [
+    ultramodernBridgeCliFlags.parentRoot,
+    ultramodernBridgeCliFlags.workspacePackage,
+    ultramodernBridgeCliFlags.workspacePackageName,
+    ultramodernBridgeCliFlags.testAlias,
+    ultramodernBridgeCliFlags.dependency,
+    ultramodernBridgeCliFlags.lockfilePolicy,
+    ultramodernBridgeCliFlags.gate,
+    ultramodernBridgeCliFlags.gateCwd,
+    ultramodernBridgeCliFlags.reactSingleton
+];
+const ultramodernBridgeCliBooleanFlags = [
+    ultramodernBridgeCliFlags.enabled
+];
+const ultramodernBridgeLockfilePolicies = [
+    'nested',
+    'parent'
+];
+export { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeCliValueFlags, ultramodernBridgeLockfilePolicies };

package/dist/esm/ultramodern-workspace/bridge-config/shared.js

@@ -0,0 +1,51 @@
+import { ultramodernBridgeCliBooleanFlags, ultramodernBridgeCliFlags, ultramodernBridgeLockfilePolicies } from "./schema.js";
+function rejectBooleanFlagValues(args) {
+    for (const flag of ultramodernBridgeCliBooleanFlags)if (args.some((arg)=>arg.startsWith(`${flag}=`))) throw new Error(`${flag} does not accept a value.`);
+}
+function readRepeatedOptionValues(args, flag) {
+    const values = [];
+    for(let index = 0; index < args.length; index++){
+        const arg = args[index];
+        if (arg === flag) {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value.`);
+            values.push(value);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+    }
+    return values;
+}
+function readSingleValue(args, flag) {
+    const values = readRepeatedOptionValues(args, flag);
+    if (values.length > 1) throw new Error(`${flag} can be provided only once.`);
+    return values[0];
+}
+function readCsvOptionValues(args, flag) {
+    return readRepeatedOptionValues(args, flag).flatMap((value)=>value.split(',').map((entry)=>entry.trim()).filter(Boolean));
+}
+function requireNonEmptyValue(value, label) {
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${label} must be a non-empty string.`);
+    return value.trim();
+}
+function parseLockfilePolicy(value) {
+    if (!ultramodernBridgeLockfilePolicies.includes(value)) throw new Error(`${ultramodernBridgeCliFlags.lockfilePolicy} must be "nested" or "parent".`);
+    return value;
+}
+function splitAssignment(value, flag, usage) {
+    const separator = value.indexOf('=');
+    if (-1 === separator) throw new Error(`${flag} must use ${usage}.`);
+    return {
+        left: value.slice(0, separator),
+        right: value.slice(separator + 1)
+    };
+}
+function uniqueNonEmptyValues(values, label) {
+    const unique = new Set();
+    for (const [index, value] of values.entries())unique.add(requireNonEmptyValue(value, `${label}[${index}]`));
+    return [
+        ...unique
+    ];
+}
+export { parseLockfilePolicy, readCsvOptionValues, readRepeatedOptionValues, readSingleValue, rejectBooleanFlagValues, requireNonEmptyValue, splitAssignment, uniqueNonEmptyValues };

package/dist/esm/ultramodern-workspace/bridge-config/validation.js

@@ -0,0 +1,27 @@
+import { defaultReactSingletons } from "./defaults.js";
+function validateParentPackageCoverage(workspacePackages, dependencies) {
+    const declaredPackages = new Set();
+    for (const [index, entry] of workspacePackages.entries()){
+        const label = `bridge.workspacePackages[${index}]`;
+        const packageNames = entry.packageNames ?? [];
+        if (0 === packageNames.length && (entry.testAliases ?? []).length > 0) throw new Error(`${label}.packageNames must declare the parent package names covered by "${entry.pattern}" before testAliases can be checked.`);
+        for (const packageName of packageNames)declaredPackages.add(packageName);
+        for (const alias of entry.testAliases ?? []){
+            if (!packageNames.some((packageName)=>aliasMatchesPackage(alias.alias, packageName))) throw new Error(`${label}.testAliases entry "${alias.alias}" must match one of ${label}.packageNames.`);
+            if (pointsAtBuildOutput(alias.target)) throw new Error(`${label}.testAliases target "${alias.target}" must point at source files, not dist output.`);
+        }
+    }
+    const missingDependencies = dependencies.filter((dependency)=>!declaredPackages.has(dependency));
+    if (declaredPackages.size > 0 && missingDependencies.length > 0) throw new Error(`Bridge mode dependencies must be declared by bridge.workspacePackages[].packageNames: ${missingDependencies.join(', ')}.`);
+}
+function aliasMatchesPackage(alias, packageName) {
+    return alias === packageName || alias.startsWith(`${packageName}/`);
+}
+function pointsAtBuildOutput(target) {
+    return target.split(/[\\/]/u).includes('dist');
+}
+function validateReactSingletons(reactSingletons) {
+    const missing = defaultReactSingletons.filter((packageName)=>!reactSingletons.includes(packageName));
+    if (missing.length > 0) throw new Error(`Bridge mode React singleton/dedupe declarations must include ${defaultReactSingletons.join(' and ')}. Missing: ${missing.join(', ')}.`);
+}
+export { validateParentPackageCoverage, validateReactSingletons };

package/dist/esm/ultramodern-workspace/bridge-config/workspace-packages.js

@@ -0,0 +1,67 @@
+import { ultramodernBridgeCliFlags } from "./schema.js";
+import { readRepeatedOptionValues, requireNonEmptyValue, splitAssignment, uniqueNonEmptyValues } from "./shared.js";
+function readWorkspacePackages(args) {
+    const drafts = new Map();
+    const getDraft = (pattern)=>{
+        const normalizedPattern = requireNonEmptyValue(pattern, ultramodernBridgeCliFlags.workspacePackage);
+        const existing = drafts.get(normalizedPattern);
+        if (existing) return existing;
+        const draft = {
+            pattern: normalizedPattern,
+            packageNames: [],
+            testAliases: []
+        };
+        drafts.set(normalizedPattern, draft);
+        return draft;
+    };
+    for (const pattern of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackage))getDraft(pattern);
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.workspacePackageName)){
+        const { left: pattern, right: packageNames } = splitAssignment(value, ultramodernBridgeCliFlags.workspacePackageName, '<pattern>=<package-name>[,<package-name>]');
+        getDraft(pattern).packageNames.push(...packageNames.split(',').map((packageName)=>packageName.trim()).filter(Boolean));
+    }
+    for (const value of readRepeatedOptionValues(args, ultramodernBridgeCliFlags.testAlias)){
+        const separator = value.indexOf(':');
+        if (-1 === separator) throw new Error(`${ultramodernBridgeCliFlags.testAlias} must use <pattern>:<alias>=<target>.`);
+        const pattern = value.slice(0, separator);
+        const aliasDefinition = value.slice(separator + 1);
+        const { left: alias, right: target } = splitAssignment(aliasDefinition, ultramodernBridgeCliFlags.testAlias, '<pattern>:<alias>=<target>');
+        getDraft(pattern).testAliases.push({
+            alias: requireNonEmptyValue(alias, `${ultramodernBridgeCliFlags.testAlias} alias`),
+            target: requireNonEmptyValue(target, `${ultramodernBridgeCliFlags.testAlias} target`)
+        });
+    }
+    return normalizeWorkspacePackages([
+        ...drafts.values()
+    ]);
+}
+function normalizeWorkspacePackages(workspacePackages) {
+    return workspacePackages.map((entry, index)=>{
+        const label = `bridge.workspacePackages[${index}]`;
+        const packageNames = entry.packageNames && entry.packageNames.length > 0 ? uniqueNonEmptyValues(entry.packageNames, `${label}.packageNames`) : void 0;
+        const testAliases = entry.testAliases && entry.testAliases.length > 0 ? normalizeTestAliases(entry.testAliases, label) : void 0;
+        return {
+            pattern: requireNonEmptyValue(entry.pattern, `${label}.pattern`),
+            ...packageNames ? {
+                packageNames
+            } : {},
+            ...testAliases ? {
+                testAliases
+            } : {}
+        };
+    });
+}
+function normalizeTestAliases(testAliases, parentLabel) {
+    const aliases = new Map();
+    for (const [index, alias] of testAliases.entries()){
+        const label = `${parentLabel}.testAliases[${index}]`;
+        const normalizedAlias = requireNonEmptyValue(alias.alias, `${label}.alias`);
+        aliases.set(normalizedAlias, {
+            alias: normalizedAlias,
+            target: requireNonEmptyValue(alias.target, `${label}.target`)
+        });
+    }
+    return [
+        ...aliases.values()
+    ];
+}
+export { normalizeWorkspacePackages, readWorkspacePackages };