@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

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

@@ -0,0 +1,324 @@
+"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__, {
+    copyRootTemplate: ()=>copyRootTemplate,
+    createPackageRoot: ()=>createPackageRoot,
+    formatGeneratedSourceCandidates: ()=>formatGeneratedSourceCandidates,
+    formatGeneratedWorkspaceFiles: ()=>formatGeneratedWorkspaceFiles,
+    readFileTemplate: ()=>readFileTemplate,
+    readJsonFile: ()=>readJsonFile,
+    renderFileTemplate: ()=>renderFileTemplate,
+    renderTemplate: ()=>renderTemplate,
+    workspaceTemplateDir: ()=>workspaceTemplateDir,
+    writeFile: ()=>writeFile,
+    writeFileReplacing: ()=>writeFileReplacing,
+    writeJson: ()=>writeJson,
+    writeJsonFile: ()=>writeJsonFile
+});
+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_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_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 fs_io_require = (0, external_node_module_namespaceObject.createRequire)(__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');
+const preformatConfigDir = '.modern-js';
+const preformatConfigPath = external_node_path_default().join(preformatConfigDir, 'ultramodern-preformat.oxfmt.config.mjs');
+const workspaceOxfmtIgnorePatterns = [
+    '.agents',
+    '.codex/skills',
+    '.output',
+    '**/*.json',
+    'dist',
+    'node_modules',
+    'repos/**',
+    '.modern',
+    '.modernjs',
+    '**/modern-tanstack/**',
+    '**/routeTree.gen.*'
+];
+const formattableExtensions = new Set([
+    '.cjs',
+    '.cts',
+    '.js',
+    '.json',
+    '.jsonc',
+    '.jsx',
+    '.mjs',
+    '.mts',
+    '.md',
+    '.mdx',
+    '.ts',
+    '.tsx',
+    '.yaml',
+    '.yml'
+]);
+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 isPathInsideRoot(root, targetPath) {
+    const relativePath = external_node_path_default().relative(root, targetPath);
+    return '' === relativePath || !relativePath.startsWith('..') && !external_node_path_default().isAbsolute(relativePath);
+}
+function findExistingAncestor(targetPath) {
+    let currentPath = targetPath;
+    while(!external_node_fs_default().existsSync(currentPath)){
+        const parentPath = external_node_path_default().dirname(currentPath);
+        if (parentPath === currentPath) return;
+        currentPath = parentPath;
+    }
+    return currentPath;
+}
+function ensureInsideRoot(root, targetPath) {
+    const absoluteRoot = external_node_path_default().resolve(root);
+    const absoluteTargetPath = external_node_path_default().resolve(targetPath);
+    if (!isPathInsideRoot(absoluteRoot, absoluteTargetPath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+    if (!external_node_fs_default().existsSync(absoluteRoot)) return;
+    const existingAncestor = findExistingAncestor(absoluteTargetPath);
+    if (!existingAncestor) return;
+    const rootRealPath = external_node_fs_default().realpathSync.native(absoluteRoot);
+    const ancestorRealPath = external_node_fs_default().realpathSync.native(existingAncestor);
+    const unresolvedRelativePath = external_node_path_default().relative(existingAncestor, absoluteTargetPath);
+    const resolvedTargetPath = external_node_path_default().resolve(ancestorRealPath, unresolvedRelativePath);
+    if (!isPathInsideRoot(rootRealPath, resolvedTargetPath)) 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 formatGeneratedSourceCandidates(sources) {
+    const temporaryRoot = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'ultramodern-format-'));
+    try {
+        sources.forEach(([relativePath, source])=>writeFileReplacing(temporaryRoot, relativePath, source));
+        const relativePaths = sources.map(([relativePath])=>relativePath);
+        formatGeneratedWorkspaceFiles(temporaryRoot, relativePaths);
+        return relativePaths.map((relativePath)=>external_node_fs_default().readFileSync(external_node_path_default().join(temporaryRoot, relativePath), 'utf-8'));
+    } finally{
+        external_node_fs_default().rmSync(temporaryRoot, {
+            force: true,
+            recursive: true
+        });
+    }
+}
+function formatGeneratedWorkspaceFiles(targetDir, relativePaths) {
+    const oxfmtBin = resolveOxfmtBin();
+    const oxfmtConfigPath = writePreformatConfig(targetDir);
+    const targets = void 0 === relativePaths ? [
+        targetDir,
+        `!${(0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().join(targetDir, 'repos'))}/**`
+    ] : relativePaths.filter((relativePath)=>formattableExtensions.has(external_node_path_default().extname(relativePath))).map((relativePath)=>external_node_path_default().join(targetDir, relativePath));
+    if (0 === targets.length) return void removePreformatConfig(targetDir);
+    try {
+        const result = (0, external_node_child_process_namespaceObject.spawnSync)(process.execPath, [
+            oxfmtBin,
+            '--config',
+            oxfmtConfigPath,
+            '--no-error-on-unmatched-pattern',
+            ...targets
+        ], {
+            cwd: targetDir,
+            encoding: 'utf-8',
+            env: {
+                ...process.env,
+                FORCE_COLOR: '0'
+            }
+        });
+        if (0 !== result.status) {
+            const detail = [
+                result.stderr.trim(),
+                result.stdout.trim()
+            ].filter(Boolean).join('\n');
+            throw new Error([
+                'Failed to format generated UltraModern workspace output.',
+                detail
+            ].filter(Boolean).join('\n'));
+        }
+    } finally{
+        removePreformatConfig(targetDir);
+    }
+}
+function writePreformatConfig(targetDir) {
+    const configPath = external_node_path_default().join(targetDir, preformatConfigPath);
+    external_node_fs_default().mkdirSync(external_node_path_default().dirname(configPath), {
+        recursive: true
+    });
+    const oxfmtUrl = (0, external_node_url_namespaceObject.pathToFileURL)(resolveOxfmtEntry()).href;
+    const ultraciteConfigUrl = (0, external_node_url_namespaceObject.pathToFileURL)(resolveUltraciteOxfmtConfig()).href;
+    external_node_fs_default().writeFileSync(configPath, [
+        `import { defineConfig } from ${JSON.stringify(oxfmtUrl)};`,
+        `import ultracite from ${JSON.stringify(ultraciteConfigUrl)};`,
+        '',
+        'export default defineConfig({',
+        '  ...ultracite,',
+        '  ignorePatterns: [',
+        ...workspaceOxfmtIgnorePatterns.map((pattern)=>`    ${JSON.stringify(pattern)},`),
+        '  ],',
+        '  singleQuote: true,',
+        '});',
+        ''
+    ].join('\n'), 'utf-8');
+    return configPath;
+}
+function removePreformatConfig(targetDir) {
+    external_node_fs_default().rmSync(external_node_path_default().join(targetDir, preformatConfigPath), {
+        force: true
+    });
+    try {
+        external_node_fs_default().rmdirSync(external_node_path_default().join(targetDir, preformatConfigDir));
+    } catch  {}
+}
+function resolveOxfmtBin() {
+    const packageJsonPath = fs_io_require.resolve('oxfmt/package.json');
+    const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf-8'));
+    const binPath = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.oxfmt;
+    if ('string' != typeof binPath || 0 === binPath.length) throw new Error('Unable to resolve oxfmt binary from package metadata.');
+    return external_node_path_default().join(external_node_path_default().dirname(packageJsonPath), binPath);
+}
+function resolveOxfmtEntry() {
+    return fs_io_require.resolve('oxfmt');
+}
+function resolveUltraciteOxfmtConfig() {
+    return fs_io_require.resolve('ultracite/oxfmt');
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key)=>data[key] ?? match);
+}
+function collectTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        let entries;
+        try {
+            entries = external_node_fs_default().readdirSync(currentDir, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries.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 copyRootTemplate(targetDir, data, excludedRelativePaths = new Set()) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        if (excludedRelativePaths.has(relativePath)) continue;
+        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.copyRootTemplate = __webpack_exports__.copyRootTemplate;
+exports.createPackageRoot = __webpack_exports__.createPackageRoot;
+exports.formatGeneratedSourceCandidates = __webpack_exports__.formatGeneratedSourceCandidates;
+exports.formatGeneratedWorkspaceFiles = __webpack_exports__.formatGeneratedWorkspaceFiles;
+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 === [
+    "copyRootTemplate",
+    "createPackageRoot",
+    "formatGeneratedSourceCandidates",
+    "formatGeneratedWorkspaceFiles",
+    "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/generation-result.cjs

@@ -0,0 +1,191 @@
+"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__, {
+    createFileSnapshot: ()=>createFileSnapshot,
+    createGenerationResult: ()=>createGenerationResult,
+    diffFileSnapshots: ()=>diffFileSnapshots,
+    ignoredSnapshotDirectories: ()=>ignoredSnapshotDirectories
+});
+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 rpc_cjs_namespaceObject = require("./api/rpc.cjs");
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.cjs");
+const up_projection_cjs_namespaceObject = require("./delivery-unit-schema/up-projection.cjs");
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+const BASELINE_COHORT_ID = 'ultramodern-platform-baseline-v1';
+const ignoredSnapshotDirectories = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function createFileSnapshot(root) {
+    const files = new Map();
+    if (!external_node_fs_default().existsSync(root)) return files;
+    function collect(currentDir) {
+        for (const entry of external_node_fs_default().readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((left, right)=>left.name.localeCompare(right.name))){
+            if (entry.isDirectory() && ignoredSnapshotDirectories.has(entry.name)) continue;
+            const entryPath = external_node_path_default().join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) {
+                const relativePath = (0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().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
+            ])),
+        apiPrefixes: Object.fromEntries(createdApps.filter((app)=>app.apiPrefix).map((app)=>[
+                app.id,
+                app.apiPrefix
+            ])),
+        generatedContractPath: external_descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH,
+        warnings: options.warnings ?? [],
+        deliveryUnits: options.createdApps.map((app)=>createGeneratedDeliveryUnitDescriptor(options.packageScope, app))
+    };
+}
+function createGeneratedDeliveryUnitDescriptor(scope, app) {
+    const record = (0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, app);
+    const surfaces = Object.entries(app.exposes ?? {}).map(([key, value])=>(0, up_projection_cjs_namespaceObject.exposeSurface)(app, key, value));
+    if ((0, external_descriptors_cjs_namespaceObject.appHasApi)(app)) surfaces.push((0, up_projection_cjs_namespaceObject.apiSurface)(app.api, (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(app), 'rpc' === (0, external_descriptors_cjs_namespaceObject.resolveApiProtocol)(app) ? (0, rpc_cjs_namespaceObject.rpcPath)(app) : app.api.prefix));
+    const canonicalKind = 'shell' === app.kind ? 'shell' : app.deliveryUnitKind ?? 'microvertical';
+    return {
+        unitId: record.unitId,
+        kind: canonicalKind,
+        owner: (0, external_types_cjs_namespaceObject.resolveOwnerAttribution)(app.ownership),
+        sourceRevision: record.sourceRevision,
+        buildMarker: record.buildMarker,
+        baselineCohort: {
+            cohortId: BASELINE_COHORT_ID,
+            resolved: {
+                react: external_versions_cjs_namespaceObject.REACT_VERSION,
+                tanstackRouter: external_versions_cjs_namespaceObject.TANSTACK_ROUTER_VERSION,
+                effect: external_versions_cjs_namespaceObject.EFFECT_VERSION,
+                tailwind: external_versions_cjs_namespaceObject.TAILWIND_VERSION
+            }
+        },
+        surfaces
+    };
+}
+function createGeneratedAppDescriptor(scope, app) {
+    return {
+        id: app.id,
+        directory: app.directory,
+        packageName: (0, external_naming_cjs_namespaceObject.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
+            }
+        } : {},
+        ...(0, external_descriptors_cjs_namespaceObject.appHasApi)(app) ? {
+            apiPrefix: app.api.prefix
+        } : {}
+    };
+}
+function hashFile(filePath) {
+    return external_node_crypto_default().createHash('sha256').update(external_node_fs_default().readFileSync(filePath)).digest('hex');
+}
+exports.createFileSnapshot = __webpack_exports__.createFileSnapshot;
+exports.createGenerationResult = __webpack_exports__.createGenerationResult;
+exports.diffFileSnapshots = __webpack_exports__.diffFileSnapshots;
+exports.ignoredSnapshotDirectories = __webpack_exports__.ignoredSnapshotDirectories;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createFileSnapshot",
+    "createGenerationResult",
+    "diffFileSnapshots",
+    "ignoredSnapshotDirectories"
+].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,79 @@
+"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__, {
+    BASELINE_DEPENDENCY_PINS: ()=>external_overlay_baseline_guard_cjs_namespaceObject.BASELINE_DEPENDENCY_PINS,
+    OverlayBaselineRelaxationError: ()=>external_overlay_baseline_guard_cjs_namespaceObject.OverlayBaselineRelaxationError,
+    PRIMARY_SHELL_ID: ()=>external_shells_cjs_namespaceObject.PRIMARY_SHELL_ID,
+    SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES: ()=>external_shared_patches_cjs_namespaceObject.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES,
+    addUltramodernShell: ()=>external_add_shell_cjs_namespaceObject.addUltramodernShell,
+    addUltramodernVertical: ()=>external_add_vertical_cjs_namespaceObject.addUltramodernVertical,
+    createShellDescriptor: ()=>external_shells_cjs_namespaceObject.createShellDescriptor,
+    generateUltramodernWorkspace: ()=>external_write_workspace_cjs_namespaceObject.generateUltramodernWorkspace,
+    normalizeUltramodernBridgeConfig: ()=>external_bridge_config_cjs_namespaceObject.normalizeUltramodernBridgeConfig,
+    planUltramodernShell: ()=>external_add_shell_cjs_namespaceObject.planUltramodernShell,
+    planUltramodernVertical: ()=>external_add_vertical_cjs_namespaceObject.planUltramodernVertical,
+    resolveConfiguredAdditionalShells: ()=>external_shells_cjs_namespaceObject.resolveConfiguredAdditionalShells
+});
+const external_add_shell_cjs_namespaceObject = require("./add-shell.cjs");
+const external_add_vertical_cjs_namespaceObject = require("./add-vertical.cjs");
+const external_bridge_config_cjs_namespaceObject = require("./bridge-config.cjs");
+const external_overlay_baseline_guard_cjs_namespaceObject = require("./overlay-baseline-guard.cjs");
+const external_shared_patches_cjs_namespaceObject = require("./shared-patches.cjs");
+const external_shells_cjs_namespaceObject = require("./shells.cjs");
+const external_write_workspace_cjs_namespaceObject = require("./write-workspace.cjs");
+exports.BASELINE_DEPENDENCY_PINS = __webpack_exports__.BASELINE_DEPENDENCY_PINS;
+exports.OverlayBaselineRelaxationError = __webpack_exports__.OverlayBaselineRelaxationError;
+exports.PRIMARY_SHELL_ID = __webpack_exports__.PRIMARY_SHELL_ID;
+exports.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = __webpack_exports__.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES;
+exports.addUltramodernShell = __webpack_exports__.addUltramodernShell;
+exports.addUltramodernVertical = __webpack_exports__.addUltramodernVertical;
+exports.createShellDescriptor = __webpack_exports__.createShellDescriptor;
+exports.generateUltramodernWorkspace = __webpack_exports__.generateUltramodernWorkspace;
+exports.normalizeUltramodernBridgeConfig = __webpack_exports__.normalizeUltramodernBridgeConfig;
+exports.planUltramodernShell = __webpack_exports__.planUltramodernShell;
+exports.planUltramodernVertical = __webpack_exports__.planUltramodernVertical;
+exports.resolveConfiguredAdditionalShells = __webpack_exports__.resolveConfiguredAdditionalShells;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BASELINE_DEPENDENCY_PINS",
+    "OverlayBaselineRelaxationError",
+    "PRIMARY_SHELL_ID",
+    "SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES",
+    "addUltramodernShell",
+    "addUltramodernVertical",
+    "createShellDescriptor",
+    "generateUltramodernWorkspace",
+    "normalizeUltramodernBridgeConfig",
+    "planUltramodernShell",
+    "planUltramodernVertical",
+    "resolveConfiguredAdditionalShells"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});