@bleedingdev/modern-js-create 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/ultramodern-workspace/fs-io.cjs

@@ -0,0 +1,191 @@
+"use strict";
+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)=>{
+            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__, {
+    assertSafeRelativePath: ()=>assertSafeRelativePath,
+    collectTemplateFiles: ()=>collectTemplateFiles,
+    copyRootTemplate: ()=>copyRootTemplate,
+    createPackageRoot: ()=>createPackageRoot,
+    ensureInsideRoot: ()=>ensureInsideRoot,
+    fileTemplatesDir: ()=>fileTemplatesDir,
+    hashFile: ()=>hashFile,
+    hashTemplateTree: ()=>hashTemplateTree,
+    readFileTemplate: ()=>readFileTemplate,
+    readJsonFile: ()=>readJsonFile,
+    renderFileTemplate: ()=>renderFileTemplate,
+    renderTemplate: ()=>renderTemplate,
+    workspaceTemplateDir: ()=>workspaceTemplateDir,
+    writeFile: ()=>writeFile,
+    writeFileReplacing: ()=>writeFileReplacing,
+    writeJson: ()=>writeJson,
+    writeJsonFile: ()=>writeJsonFile
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
+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_node_url_namespaceObject = require("node:url");
+const external_create_package_root_cjs_namespaceObject = require("../create-package-root.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const fs_io_dirname = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+const createPackageRoot = (0, external_create_package_root_cjs_namespaceObject.resolveCreatePackageRoot)(fs_io_dirname);
+const workspaceTemplateDir = external_node_path_default().join(createPackageRoot, 'template-workspace');
+const fileTemplatesDir = external_node_path_default().join(createPackageRoot, 'templates');
+function readFileTemplate(relativePath) {
+    return external_node_fs_default().readFileSync(external_node_path_default().join(fileTemplatesDir, relativePath), 'utf-8');
+}
+function renderFileTemplate(relativePath, data) {
+    return renderTemplate(readFileTemplate(`${relativePath}.handlebars`), data);
+}
+function assertSafeRelativePath(relativePath) {
+    if (0 === relativePath.length || external_node_path_default().isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
+}
+function ensureInsideRoot(root, targetPath) {
+    const relativePath = external_node_path_default().relative(root, targetPath);
+    if (relativePath.startsWith('..') || external_node_path_default().isAbsolute(relativePath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+}
+function writeFile(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = external_node_path_default().join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    if (external_node_fs_default().existsSync(filePath)) throw new Error(`Refusing to overwrite generated workspace file: ${relativePath}`);
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+        recursive: true
+    });
+    external_node_fs_default().writeFileSync(filePath, content, 'utf-8');
+}
+function writeFileReplacing(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = external_node_path_default().join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(filePath), {
+        recursive: true
+    });
+    external_node_fs_default().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 external_node_fs_default().readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((a, b)=>a.name.localeCompare(b.name))){
+            const entryPath = external_node_path_default().join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push((0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function hashFile(filePath) {
+    return external_node_crypto_default().createHash('sha256').update(external_node_fs_default().readFileSync(filePath)).digest('hex');
+}
+function hashTemplateTree(dir) {
+    const hash = external_node_crypto_default().createHash('sha256');
+    for (const relativePath of collectTemplateFiles(dir)){
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(hashFile(external_node_path_default().join(dir, relativePath)));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function copyRootTemplate(targetDir, data) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        const sourcePath = external_node_path_default().join(workspaceTemplateDir, relativePath);
+        const outputPath = relativePath.replace(/\.handlebars$/, '');
+        const content = relativePath.endsWith('.handlebars') ? renderTemplate(external_node_fs_default().readFileSync(sourcePath, 'utf-8'), data) : external_node_fs_default().readFileSync(sourcePath, 'utf-8');
+        writeFile(targetDir, outputPath, content);
+    }
+}
+function readJsonFile(filePath) {
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    external_node_fs_default().writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+exports.assertSafeRelativePath = __webpack_exports__.assertSafeRelativePath;
+exports.collectTemplateFiles = __webpack_exports__.collectTemplateFiles;
+exports.copyRootTemplate = __webpack_exports__.copyRootTemplate;
+exports.createPackageRoot = __webpack_exports__.createPackageRoot;
+exports.ensureInsideRoot = __webpack_exports__.ensureInsideRoot;
+exports.fileTemplatesDir = __webpack_exports__.fileTemplatesDir;
+exports.hashFile = __webpack_exports__.hashFile;
+exports.hashTemplateTree = __webpack_exports__.hashTemplateTree;
+exports.readFileTemplate = __webpack_exports__.readFileTemplate;
+exports.readJsonFile = __webpack_exports__.readJsonFile;
+exports.renderFileTemplate = __webpack_exports__.renderFileTemplate;
+exports.renderTemplate = __webpack_exports__.renderTemplate;
+exports.workspaceTemplateDir = __webpack_exports__.workspaceTemplateDir;
+exports.writeFile = __webpack_exports__.writeFile;
+exports.writeFileReplacing = __webpack_exports__.writeFileReplacing;
+exports.writeJson = __webpack_exports__.writeJson;
+exports.writeJsonFile = __webpack_exports__.writeJsonFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertSafeRelativePath",
+    "collectTemplateFiles",
+    "copyRootTemplate",
+    "createPackageRoot",
+    "ensureInsideRoot",
+    "fileTemplatesDir",
+    "hashFile",
+    "hashTemplateTree",
+    "readFileTemplate",
+    "readJsonFile",
+    "renderFileTemplate",
+    "renderTemplate",
+    "workspaceTemplateDir",
+    "writeFile",
+    "writeFileReplacing",
+    "writeJson",
+    "writeJsonFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,48 @@
+"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__, {
+    addUltramodernVertical: ()=>external_add_vertical_cjs_namespaceObject.addUltramodernVertical,
+    generateUltramodernWorkspace: ()=>external_write_workspace_cjs_namespaceObject.generateUltramodernWorkspace,
+    ultramodernWorkspaceVersions: ()=>external_versions_cjs_namespaceObject.ultramodernWorkspaceVersions
+});
+const external_add_vertical_cjs_namespaceObject = require("./add-vertical.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const external_write_workspace_cjs_namespaceObject = require("./write-workspace.cjs");
+exports.addUltramodernVertical = __webpack_exports__.addUltramodernVertical;
+exports.generateUltramodernWorkspace = __webpack_exports__.generateUltramodernWorkspace;
+exports.ultramodernWorkspaceVersions = __webpack_exports__.ultramodernWorkspaceVersions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "addUltramodernVertical",
+    "generateUltramodernWorkspace",
+    "ultramodernWorkspaceVersions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,173 @@
+"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__);
+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)));
+}
+__webpack_require__.d(__webpack_exports__, {
+    createAppLocaleMessages: ()=>createAppLocaleMessages,
+    createAppPublicLocaleMessages: ()=>createAppPublicLocaleMessages
+}, {
+    commonLocaleMessages: commonLocaleMessages,
+    createFallbackLocaleMessages: createFallbackLocaleMessages,
+    generatedLocaleResources: generatedLocaleResources
+});
+exports.commonLocaleMessages = __webpack_exports__.commonLocaleMessages;
+exports.createAppLocaleMessages = __webpack_exports__.createAppLocaleMessages;
+exports.createAppPublicLocaleMessages = __webpack_exports__.createAppPublicLocaleMessages;
+exports.createFallbackLocaleMessages = __webpack_exports__.createFallbackLocaleMessages;
+exports.generatedLocaleResources = __webpack_exports__.generatedLocaleResources;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "commonLocaleMessages",
+    "createAppLocaleMessages",
+    "createAppPublicLocaleMessages",
+    "createFallbackLocaleMessages",
+    "generatedLocaleResources"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});