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

package/dist/esm-node/ultramodern-workspace/fs-io.js

@@ -0,0 +1,91 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { normalizePath } from "./naming.js";
+const fs_io_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const createPackageRoot = resolveCreatePackageRoot(fs_io_dirname);
+const workspaceTemplateDir = node_path.join(createPackageRoot, 'template-workspace');
+const fileTemplatesDir = node_path.join(createPackageRoot, 'templates');
+function readFileTemplate(relativePath) {
+    return node_fs.readFileSync(node_path.join(fileTemplatesDir, relativePath), 'utf-8');
+}
+function renderFileTemplate(relativePath, data) {
+    return renderTemplate(readFileTemplate(`${relativePath}.handlebars`), data);
+}
+function assertSafeRelativePath(relativePath) {
+    if (0 === relativePath.length || node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
+}
+function ensureInsideRoot(root, targetPath) {
+    const relativePath = node_path.relative(root, targetPath);
+    if (relativePath.startsWith('..') || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+}
+function writeFile(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    if (node_fs.existsSync(filePath)) throw new Error(`Refusing to overwrite generated workspace file: ${relativePath}`);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeFileReplacing(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeJson(targetDir, relativePath, value) {
+    writeFile(targetDir, relativePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key)=>data[key] ?? match);
+}
+function collectTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((a, b)=>a.name.localeCompare(b.name))){
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push(normalizePath(node_path.relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+function hashTemplateTree(dir) {
+    const hash = node_crypto.createHash('sha256');
+    for (const relativePath of collectTemplateFiles(dir)){
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(hashFile(node_path.join(dir, relativePath)));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function copyRootTemplate(targetDir, data) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        const sourcePath = node_path.join(workspaceTemplateDir, relativePath);
+        const outputPath = relativePath.replace(/\.handlebars$/, '');
+        const content = relativePath.endsWith('.handlebars') ? renderTemplate(node_fs.readFileSync(sourcePath, 'utf-8'), data) : node_fs.readFileSync(sourcePath, 'utf-8');
+        writeFile(targetDir, outputPath, content);
+    }
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+export { assertSafeRelativePath, collectTemplateFiles, copyRootTemplate, createPackageRoot, ensureInsideRoot, fileTemplatesDir, hashFile, hashTemplateTree, readFileTemplate, readJsonFile, renderFileTemplate, renderTemplate, workspaceTemplateDir, writeFile, writeFileReplacing, writeJson, writeJsonFile };

package/dist/esm-node/ultramodern-workspace/generation-result.js

@@ -0,0 +1,103 @@
+import "node:module";
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { GENERATED_CONTRACT_PATH, appHasEffectApi } from "./descriptors.js";
+import { normalizePath, packageName } from "./naming.js";
+const ignoredSnapshotDirectories = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function createFileSnapshot(root) {
+    const files = new Map();
+    if (!node_fs.existsSync(root)) return files;
+    function collect(currentDir) {
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((left, right)=>left.name.localeCompare(right.name))){
+            if (entry.isDirectory() && ignoredSnapshotDirectories.has(entry.name)) continue;
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) {
+                const relativePath = normalizePath(node_path.relative(root, entryPath));
+                files.set(relativePath, hashFile(entryPath));
+            }
+        }
+    }
+    collect(root);
+    return files;
+}
+function diffFileSnapshots(before, after) {
+    const createdPaths = [];
+    const rewrittenPaths = [];
+    for (const [relativePath, hash] of after){
+        const previousHash = before.get(relativePath);
+        if (void 0 === previousHash) createdPaths.push(relativePath);
+        else if (previousHash !== hash) rewrittenPaths.push(relativePath);
+    }
+    return {
+        createdPaths: createdPaths.sort(),
+        rewrittenPaths: rewrittenPaths.sort()
+    };
+}
+function createGenerationResult(options) {
+    const createdApps = options.createdApps.map((app)=>createGeneratedAppDescriptor(options.packageScope, app));
+    return {
+        operation: options.operation,
+        workspaceRoot: options.workspaceRoot,
+        packageScope: options.packageScope,
+        packageSource: {
+            ...options.packageSource
+        },
+        createdApps,
+        createdPaths: [
+            ...options.createdPaths
+        ].sort(),
+        rewrittenPaths: [
+            ...options.rewrittenPaths
+        ].sort(),
+        assignedPorts: Object.fromEntries(createdApps.map((app)=>[
+                app.id,
+                app.port
+            ])),
+        moduleFederationNames: Object.fromEntries(createdApps.map((app)=>[
+                app.id,
+                app.moduleFederationName
+            ])),
+        effectApiPrefixes: Object.fromEntries(createdApps.filter((app)=>app.effectApiPrefix).map((app)=>[
+                app.id,
+                app.effectApiPrefix
+            ])),
+        generatedContractPath: GENERATED_CONTRACT_PATH,
+        warnings: options.warnings ?? []
+    };
+}
+function createGeneratedAppDescriptor(scope, app) {
+    return {
+        id: app.id,
+        directory: app.directory,
+        packageName: packageName(scope, app.packageSuffix),
+        packageSuffix: app.packageSuffix,
+        displayName: app.displayName,
+        kind: app.kind,
+        portEnv: app.portEnv,
+        port: app.port,
+        moduleFederationName: app.mfName,
+        ...app.exposes ? {
+            exposes: {
+                ...app.exposes
+            }
+        } : {},
+        ...appHasEffectApi(app) ? {
+            effectApiPrefix: app.effectApi.prefix
+        } : {}
+    };
+}
+function hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+export { createFileSnapshot, createGenerationResult, diffFileSnapshots };

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

@@ -0,0 +1,4 @@
+import "node:module";
+export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.js";
+export { ultramodernWorkspaceVersions } from "./versions.js";
+export { generateUltramodernWorkspace } from "./write-workspace.js";

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

@@ -0,0 +1,123 @@
+import "node:module";
+const commonLocaleMessages = {
+    cs: {
+        language: {
+            cs: 'Čeština',
+            en: 'Angličtina',
+            switcher: 'Jazyk'
+        },
+        routes: {
+            home: 'Domů'
+        },
+        seo: {
+            description: 'Route-owned UltraModern plocha s lokalizovaným SSR a frameworkem řízenými public metadata.'
+        }
+    },
+    en: {
+        language: {
+            cs: 'Czech',
+            en: 'English',
+            switcher: 'Language'
+        },
+        routes: {
+            home: 'Home'
+        },
+        seo: {
+            description: 'Route-owned UltraModern surface with localized SSR and framework-owned public metadata.'
+        }
+    }
+};
+const generatedLocaleResources = {
+    cs: {
+        shell: {
+            boundaries: {
+                toggle: 'zobrazit hranice týmů'
+            },
+            hero: {
+                cardOne: 'Přidejte první business vertical příkazem create <domain> --vertical, až ho opravdu potřebujete.',
+                cardOneKicker: 'Verticaly',
+                cardTwo: 'Plný markup, styly a lokalizovaný obsah se vykreslí před hydratací.',
+                cardTwoKicker: 'Vykreslení',
+                empty: 'Zatím nejsou připojené žádné MicroVerticaly.',
+                eyebrow: 'Shell SuperApp starter',
+                lede: 'Začněte s produkčně připraveným shellem. MicroVerticaly přidávejte až podle skutečných business domén.',
+                primary: 'Shell je připraven',
+                secondary: 'Přidejte vertical, až bude potřeba'
+            },
+            language: commonLocaleMessages.cs.language,
+            remoteUnavailable: 'Remote vertical je nedostupný',
+            remotes: {},
+            routes: {
+                home: commonLocaleMessages.cs.routes.home
+            },
+            seo: {
+                description: 'UltraModern shell SuperApp s lokalizovaným SSR, Module Federation a frameworkem řízenými public metadata.'
+            },
+            title: 'UltraModern Workspace'
+        }
+    },
+    en: {
+        shell: {
+            boundaries: {
+                toggle: 'show team boundaries'
+            },
+            hero: {
+                cardOne: 'Add the first business vertical with create <domain> --vertical when the product needs one.',
+                cardOneKicker: 'Verticals',
+                cardTwo: 'Full page markup, styles, and localized content render before hydration.',
+                cardTwoKicker: 'Rendering',
+                empty: 'No MicroVerticals are connected yet.',
+                eyebrow: 'Shell SuperApp starter',
+                lede: 'Start with a production-ready shell. Add MicroVerticals later for real business domains.',
+                primary: 'Shell ready',
+                secondary: 'Add a vertical when needed'
+            },
+            language: commonLocaleMessages.en.language,
+            remoteUnavailable: 'Remote vertical unavailable',
+            remotes: {},
+            routes: {
+                home: commonLocaleMessages.en.routes.home
+            },
+            seo: {
+                description: 'UltraModern shell SuperApp with localized SSR, Module Federation, and framework-owned public metadata.'
+            },
+            title: 'UltraModern Workspace'
+        }
+    }
+};
+const verticalLocaleCopy = {
+    cs: {
+        federatedSurface: 'Federovaná plocha vlastněná tímto verticalem.',
+        remoteUnavailable: 'Remote vertical je nedostupný',
+        routeSurface: 'Routovaná plocha vlastněná tímto verticalem.',
+        widgetBody: 'Vlastní routovanou plochu verticalu.'
+    },
+    en: {
+        federatedSurface: 'Federated surface owned by this vertical.',
+        remoteUnavailable: 'Remote vertical unavailable',
+        routeSurface: 'Route surface owned by this vertical.',
+        widgetBody: 'Owns a vertical route surface.'
+    }
+};
+const createFallbackLocaleMessages = (app, language)=>({
+        ...commonLocaleMessages[language],
+        federatedSurface: verticalLocaleCopy[language].federatedSurface,
+        remoteUnavailable: verticalLocaleCopy[language].remoteUnavailable,
+        role: app.domain ?? app.kind,
+        routeSurface: verticalLocaleCopy[language].routeSurface,
+        title: app.displayName,
+        widgetBody: verticalLocaleCopy[language].widgetBody
+    });
+function createAppLocaleMessages(app, language) {
+    const domain = app.domain ?? app.id;
+    const messageKey = 'shell' === app.kind ? 'shell' : domain;
+    const messages = 'shell' === app.kind ? generatedLocaleResources[language].shell : createFallbackLocaleMessages(app, language);
+    return {
+        [messageKey]: messages
+    };
+}
+function createAppPublicLocaleMessages(app, language, remotes = []) {
+    if ('shell' !== app.kind) return createAppLocaleMessages(app, language);
+    return Object.assign({}, createAppLocaleMessages(app, language), ...remotes.map((remote)=>createAppLocaleMessages(remote, language)));
+}
+export { commonLocaleMessages, createAppLocaleMessages, createAppPublicLocaleMessages, createFallbackLocaleMessages, generatedLocaleResources };