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

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

@@ -0,0 +1,152 @@
+"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__, {
+    FIRST_ADDITIONAL_SHELL_PORT: ()=>FIRST_ADDITIONAL_SHELL_PORT,
+    PRIMARY_SHELL_ID: ()=>PRIMARY_SHELL_ID,
+    assertValidShellName: ()=>assertValidShellName,
+    createAdditionalShellConfigEntry: ()=>createAdditionalShellConfigEntry,
+    createShellDescriptor: ()=>createShellDescriptor,
+    resolveConfiguredAdditionalShells: ()=>resolveConfiguredAdditionalShells,
+    shellDeliveryUnitBlock: ()=>shellDeliveryUnitBlock
+});
+const external_delivery_unit_cjs_namespaceObject = require("./delivery-unit.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 PRIMARY_SHELL_ID = external_descriptors_cjs_namespaceObject.shellApp.id;
+const FIRST_ADDITIONAL_SHELL_PORT = 3120;
+function createShellDescriptor(name, port) {
+    const normalized = (0, external_naming_cjs_namespaceObject.toKebabCase)(name);
+    const id = `shell-${normalized}`;
+    const displayPrefix = (0, external_naming_cjs_namespaceObject.toPascalCase)(normalized).replace(/([a-z])([A-Z])/g, '$1 $2');
+    return {
+        id,
+        directory: `apps/${id}`,
+        packageSuffix: id,
+        displayName: `${displayPrefix} Shell`,
+        kind: 'shell',
+        portEnv: `SHELL_${(0, external_naming_cjs_namespaceObject.toEnvSegment)(normalized)}_PORT`,
+        port,
+        mfName: `shell${(0, external_naming_cjs_namespaceObject.toPascalCase)(normalized)}`,
+        verticalRefs: [],
+        ownership: (0, external_descriptors_cjs_namespaceObject.createNeutralOwnership)(id, 'tier-0-shell')
+    };
+}
+function assertValidShellName(name) {
+    const normalized = (0, external_naming_cjs_namespaceObject.toKebabCase)(name);
+    if (!normalized || normalized !== name) throw new Error(`Invalid Shell name "${name}". Use lowercase kebab-case.`);
+    if (`shell-${normalized}` === PRIMARY_SHELL_ID || 'super-app' === normalized) throw new Error(`Shell name "${name}" is reserved for the primary shell (${PRIMARY_SHELL_ID}).`);
+    return normalized;
+}
+function shellDeliveryUnitBlock(scope, shell) {
+    return shell.deliveryUnit ?? (0, external_delivery_unit_cjs_namespaceObject.deliveryUnitContractBlock)((0, external_delivery_unit_cjs_namespaceObject.createDeliveryUnitRecord)(scope, shell));
+}
+function createAdditionalShellConfigEntry(scope, shell, remotes = []) {
+    const verticalRefs = shell.verticalRefs ?? [];
+    return {
+        id: shell.id,
+        name: shell.id.replace(/^shell-/u, ''),
+        kind: 'shell',
+        package: (0, external_naming_cjs_namespaceObject.packageName)(scope, shell.packageSuffix),
+        path: shell.directory,
+        port: shell.port,
+        portEnv: shell.portEnv,
+        mfName: shell.mfName,
+        verticalRefs,
+        owner: (0, external_types_cjs_namespaceObject.resolveOwnerAttribution)(shell.ownership),
+        deliveryUnit: shellDeliveryUnitBlock(scope, shell),
+        moduleFederation: {
+            role: 'host',
+            name: shell.mfName,
+            verticalRefs,
+            remotes: (0, external_descriptors_cjs_namespaceObject.createModuleFederationRemoteContracts)(shell, remotes),
+            ssr: true,
+            sharedContractVersion: 'mf-ssr-contract-v1'
+        }
+    };
+}
+function resolveConfiguredAdditionalShells(config) {
+    const shells = config?.shells;
+    if (!Array.isArray(shells)) return [];
+    return shells.filter((entry)=>null !== entry && 'object' == typeof entry && !Array.isArray(entry)).map((entry)=>{
+        const id = String(entry.id ?? '');
+        const suffix = 'string' == typeof entry.package ? entry.package.split('/').at(-1) ?? id : id;
+        const name = 'string' == typeof entry.name ? entry.name : id.replace(/^shell-/, '');
+        const port = 'number' == typeof entry.port ? entry.port : FIRST_ADDITIONAL_SHELL_PORT;
+        const descriptor = createShellDescriptor(name, port);
+        const moduleFederation = entry.moduleFederation && 'object' == typeof entry.moduleFederation && !Array.isArray(entry.moduleFederation) ? entry.moduleFederation : void 0;
+        const owner = entry.owner;
+        const deliveryUnit = entry.deliveryUnit;
+        const ownerAttribution = owner && 'object' == typeof owner && !Array.isArray(owner) && 'kind' in owner && ('team' === owner.kind || 'agent' === owner.kind || 'agent-team' === owner.kind) && 'id' in owner && 'string' == typeof owner.id ? {
+            kind: owner.kind,
+            id: owner.id,
+            ...'contact' in owner && 'string' == typeof owner.contact ? {
+                contact: owner.contact
+            } : {}
+        } : void 0;
+        const ownership = void 0 === ownerAttribution ? descriptor.ownership : {
+            ...descriptor.ownership,
+            owner: ownerAttribution
+        };
+        return {
+            ...descriptor,
+            id,
+            packageSuffix: suffix,
+            ownership,
+            displayName: 'string' == typeof entry.displayName ? entry.displayName : descriptor.displayName,
+            directory: 'string' == typeof entry.path ? entry.path : descriptor.directory,
+            portEnv: 'string' == typeof entry.portEnv ? entry.portEnv : descriptor.portEnv,
+            mfName: 'string' == typeof entry.mfName ? entry.mfName : 'string' == typeof moduleFederation?.name ? moduleFederation.name : descriptor.mfName,
+            verticalRefs: Array.isArray(entry.verticalRefs) ? entry.verticalRefs.filter((ref)=>'string' == typeof ref) : Array.isArray(moduleFederation?.verticalRefs) ? moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : [],
+            ...deliveryUnit && 'object' == typeof deliveryUnit && !Array.isArray(deliveryUnit) ? {
+                deliveryUnit: deliveryUnit
+            } : {}
+        };
+    });
+}
+exports.FIRST_ADDITIONAL_SHELL_PORT = __webpack_exports__.FIRST_ADDITIONAL_SHELL_PORT;
+exports.PRIMARY_SHELL_ID = __webpack_exports__.PRIMARY_SHELL_ID;
+exports.assertValidShellName = __webpack_exports__.assertValidShellName;
+exports.createAdditionalShellConfigEntry = __webpack_exports__.createAdditionalShellConfigEntry;
+exports.createShellDescriptor = __webpack_exports__.createShellDescriptor;
+exports.resolveConfiguredAdditionalShells = __webpack_exports__.resolveConfiguredAdditionalShells;
+exports.shellDeliveryUnitBlock = __webpack_exports__.shellDeliveryUnitBlock;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FIRST_ADDITIONAL_SHELL_PORT",
+    "PRIMARY_SHELL_ID",
+    "assertValidShellName",
+    "createAdditionalShellConfigEntry",
+    "createShellDescriptor",
+    "resolveConfiguredAdditionalShells",
+    "shellDeliveryUnitBlock"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/tooling-command-catalog.cjs

@@ -0,0 +1,147 @@
+"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 defineToolingCommand = (command)=>({
+        ...command,
+        wrapperPath: `scripts/${command.wrapperName}.mts`
+    });
+const generatedToolingCommands = [
+    defineToolingCommand({
+        id: 'validate',
+        command: 'validate',
+        wrapperName: 'validate-ultramodern-workspace',
+        contractKey: 'validate',
+        rootScript: 'contract:check'
+    }),
+    defineToolingCommand({
+        id: 'typecheck',
+        command: 'typecheck',
+        wrapperName: 'ultramodern-typecheck',
+        contractKey: 'typecheck',
+        rootScript: 'typecheck',
+        templatePath: "templates/workspace-scripts/ultramodern-typecheck.mjs",
+        cwd: 'invocation'
+    }),
+    defineToolingCommand({
+        id: 'mfTypes',
+        command: 'mf-types',
+        wrapperName: 'assert-mf-types',
+        contractKey: 'mfTypes',
+        rootScript: 'mf:types'
+    }),
+    defineToolingCommand({
+        id: 'publicSurface',
+        command: 'public-surface',
+        wrapperName: 'generate-public-surface-assets',
+        contractKey: 'publicSurface',
+        templatePath: "templates/workspace-scripts/generate-public-surface-assets.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationGenerate',
+        command: 'backend-federation-generate',
+        wrapperName: 'generate-node-backend-federation',
+        contractKey: 'backendFederationGenerate',
+        rootScript: 'node:backend-federation:generate',
+        templatePath: "templates/workspace-scripts/generate-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'backendFederationProof',
+        command: 'backend-federation-proof',
+        wrapperName: 'proof-node-backend-federation',
+        contractKey: 'backendFederationProof',
+        rootScript: 'node:proof',
+        templatePath: "templates/workspace-scripts/proof-node-backend-federation.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareProof',
+        command: 'cloudflare-proof',
+        wrapperName: 'proof-cloudflare-version',
+        contractKey: 'cloudflareProof',
+        rootScript: 'cloudflare:proof',
+        templatePath: "templates/workspace-scripts/proof-cloudflare-version.mjs"
+    }),
+    defineToolingCommand({
+        id: 'cloudflareOutputVerify',
+        command: 'cloudflare-output-verify',
+        wrapperName: 'verify-cloudflare-output',
+        contractKey: 'cloudflareOutputVerify',
+        rootScript: 'cloudflare-output:verify'
+    }),
+    defineToolingCommand({
+        id: 'performanceReadiness',
+        command: 'performance-readiness',
+        wrapperName: 'ultramodern-performance-readiness',
+        contractKey: 'performanceReadiness',
+        rootScript: 'performance:readiness',
+        templatePath: "templates/workspace-scripts/ultramodern-performance-readiness.mjs"
+    }),
+    defineToolingCommand({
+        id: 'migrateStrictEffect',
+        command: 'migrate-strict-effect',
+        wrapperName: 'migrate-strict-effect',
+        contractKey: 'migrateStrictEffect',
+        rootScript: 'migrate:strict-effect'
+    }),
+    defineToolingCommand({
+        id: 'routesGenerate',
+        command: 'routes-generate',
+        wrapperName: 'generate-tanstack-routes',
+        contractKey: 'routesGenerate'
+    })
+];
+const toolingCommandById = Object.fromEntries(generatedToolingCommands.map((command)=>[
+        command.id,
+        command
+    ]));
+const GENERATED_TOOLING_COMMANDS = toolingCommandById;
+const generatedToolingCommandList = ()=>generatedToolingCommands.map((command)=>command.command);
+const createToolingWrapperContract = ()=>Object.fromEntries(generatedToolingCommands.map((command)=>[
+            command.contractKey,
+            command.wrapperPath
+        ]));
+const createGeneratedToolingWrapperMap = createToolingWrapperContract;
+__webpack_require__.d(__webpack_exports__, {}, {
+    GENERATED_TOOLING_COMMANDS: GENERATED_TOOLING_COMMANDS,
+    createGeneratedToolingWrapperMap: createGeneratedToolingWrapperMap,
+    generatedToolingCommandList: generatedToolingCommandList,
+    generatedToolingCommands: generatedToolingCommands
+});
+exports.GENERATED_TOOLING_COMMANDS = __webpack_exports__.GENERATED_TOOLING_COMMANDS;
+exports.createGeneratedToolingWrapperMap = __webpack_exports__.createGeneratedToolingWrapperMap;
+exports.generatedToolingCommandList = __webpack_exports__.generatedToolingCommandList;
+exports.generatedToolingCommands = __webpack_exports__.generatedToolingCommands;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GENERATED_TOOLING_COMMANDS",
+    "createGeneratedToolingWrapperMap",
+    "generatedToolingCommandList",
+    "generatedToolingCommands"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,201 @@
+"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__, {
+    createAppMfTypesTsConfig: ()=>createAppMfTypesTsConfig,
+    createAppTsConfig: ()=>createAppTsConfig,
+    createPackageTsConfig: ()=>createPackageTsConfig,
+    createRootTsConfig: ()=>createRootTsConfig,
+    createSharedPackageTsConfig: ()=>createSharedPackageTsConfig,
+    createTsConfigBase: ()=>createTsConfigBase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_effect_diagnostics_cjs_namespaceObject = require("./effect-diagnostics.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+function createTsConfigBase() {
+    return {
+        compilerOptions: {
+            target: 'ESNext',
+            lib: [
+                'ESNext',
+                'DOM',
+                'DOM.Iterable'
+            ],
+            module: 'preserve',
+            moduleResolution: 'Bundler',
+            moduleDetection: 'force',
+            jsx: 'preserve',
+            isolatedModules: true,
+            verbatimModuleSyntax: true,
+            strict: true,
+            noEmit: true,
+            allowImportingTsExtensions: true,
+            allowJs: true,
+            esModuleInterop: true,
+            noUncheckedIndexedAccess: true,
+            exactOptionalPropertyTypes: true,
+            noImplicitOverride: true,
+            noFallthroughCasesInSwitch: true,
+            noPropertyAccessFromIndexSignature: true,
+            noImplicitReturns: true,
+            resolveJsonModule: true,
+            plugins: [
+                {
+                    name: '@effect/language-service',
+                    diagnostics: true,
+                    includeSuggestionsInTsc: true,
+                    ignoreEffectSuggestionsInTscExitCode: false,
+                    ignoreEffectWarningsInTscExitCode: false,
+                    ignoreEffectErrorsInTscExitCode: false,
+                    skipDisabledOptimization: true,
+                    diagnosticSeverity: Object.fromEntries(external_effect_diagnostics_cjs_namespaceObject.effectDiagnostics.map((name)=>[
+                            name,
+                            'error'
+                        ]))
+                }
+            ]
+        }
+    };
+}
+function createTsBuildInfoFile(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${(0, external_naming_cjs_namespaceObject.relativeRootFor)(packageDir)}/node_modules/.cache/tsgo/${cacheKey}.tsbuildinfo`;
+}
+function createTsDeclarationOutDir(packageDir) {
+    const cacheKey = packageDir.replace(/[^a-zA-Z0-9._-]+/gu, '__');
+    return `${(0, external_naming_cjs_namespaceObject.relativeRootFor)(packageDir)}/node_modules/.cache/tsgo/declarations/${cacheKey}`;
+}
+function createReferences(packageDir, references) {
+    return [
+        ...new Set(references)
+    ].filter((reference)=>reference !== packageDir).map((reference)=>({
+            path: external_node_path_default().relative(packageDir, reference).split(external_node_path_default().sep).join('/')
+        }));
+}
+function createPackageTsConfig(packageDir, options = {}) {
+    const resolvedOptions = 'boolean' == typeof options ? {
+        includeApi: options
+    } : options;
+    const include = resolvedOptions.include ?? [
+        'src',
+        'locales/**/*.json',
+        'package.json',
+        'shared'
+    ];
+    if (resolvedOptions.includeServer) include.push('server');
+    if (resolvedOptions.includeApi) include.push('api');
+    const references = createReferences(packageDir, resolvedOptions.references ?? []);
+    const tsconfig = {
+        extends: `${(0, external_naming_cjs_namespaceObject.relativeRootFor)(packageDir)}/tsconfig.base.json`,
+        compilerOptions: {
+            composite: true,
+            declaration: true,
+            declarationMap: false,
+            emitDeclarationOnly: true,
+            incremental: true,
+            noEmit: false,
+            outDir: createTsDeclarationOutDir(packageDir),
+            tsBuildInfoFile: createTsBuildInfoFile(packageDir)
+        },
+        include
+    };
+    if (references.length > 0) tsconfig.references = references;
+    return tsconfig;
+}
+function createAppTsConfig(app, remotes = []) {
+    const references = [
+        ...external_descriptors_cjs_namespaceObject.sharedPackages.map((sharedPackage)=>sharedPackage.directory),
+        ...'shell' === app.kind ? [] : (0, external_descriptors_cjs_namespaceObject.resolveRemoteRefs)(app, remotes).map((remote)=>remote.directory)
+    ];
+    return createPackageTsConfig(app.directory, {
+        includeApi: (0, external_descriptors_cjs_namespaceObject.appHasApi)(app),
+        includeServer: true,
+        references
+    });
+}
+function createAppMfTypesTsConfig(app) {
+    const exposedFiles = Object.entries(app.exposes ?? {}).sort(([left], [right])=>'./Route' === left ? -1 : './Route' === right ? 1 : 0).map(([, exposePath])=>exposePath.replace(/^\.\//u, ''));
+    return {
+        extends: `${(0, external_naming_cjs_namespaceObject.relativeRootFor)(app.directory)}/tsconfig.base.json`,
+        include: [
+            ...new Set([
+                ...exposedFiles,
+                'src/modern-app-env.d.ts'
+            ])
+        ]
+    };
+}
+function createSharedPackageTsConfig(packageDir) {
+    return createPackageTsConfig(packageDir, {
+        include: [
+            'src'
+        ]
+    });
+}
+function createRootTsConfig(apps = []) {
+    return {
+        files: [],
+        references: [
+            ...external_descriptors_cjs_namespaceObject.sharedPackages.map((sharedPackage)=>({
+                    path: sharedPackage.directory
+                })),
+            ...apps.map((app)=>({
+                    path: app.directory
+                }))
+        ]
+    };
+}
+exports.createAppMfTypesTsConfig = __webpack_exports__.createAppMfTypesTsConfig;
+exports.createAppTsConfig = __webpack_exports__.createAppTsConfig;
+exports.createPackageTsConfig = __webpack_exports__.createPackageTsConfig;
+exports.createRootTsConfig = __webpack_exports__.createRootTsConfig;
+exports.createSharedPackageTsConfig = __webpack_exports__.createSharedPackageTsConfig;
+exports.createTsConfigBase = __webpack_exports__.createTsConfigBase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAppMfTypesTsConfig",
+    "createAppTsConfig",
+    "createPackageTsConfig",
+    "createRootTsConfig",
+    "createSharedPackageTsConfig",
+    "createTsConfigBase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,88 @@
+"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__);
+function sortJsonValue(value) {
+    if (Array.isArray(value)) return value.map(sortJsonValue);
+    if (null !== value && 'object' == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entry])=>[
+            key,
+            sortJsonValue(entry)
+        ]));
+    return value;
+}
+function isVerticalPreset(value) {
+    return 'full-stack' === value || 'api-only' === value || 'ui-only' === value;
+}
+function isVerticalApiProtocol(value) {
+    return 'rest' === value || 'rpc' === value;
+}
+function isWorkspaceDeliveryUnitKind(value) {
+    return 'microvertical' === value || 'horizontal-remote' === value;
+}
+function resolveOwnerAttribution(ownership) {
+    return ownership.owner ?? {
+        kind: 'team',
+        id: ownership.team
+    };
+}
+const supportedWorkspaceLanguages = [
+    'en',
+    'cs'
+];
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+__webpack_require__.d(__webpack_exports__, {
+    isRecord: ()=>isRecord,
+    isVerticalApiProtocol: ()=>isVerticalApiProtocol,
+    isVerticalPreset: ()=>isVerticalPreset,
+    isWorkspaceDeliveryUnitKind: ()=>isWorkspaceDeliveryUnitKind,
+    resolveOwnerAttribution: ()=>resolveOwnerAttribution,
+    sortJsonValue: ()=>sortJsonValue
+}, {
+    supportedWorkspaceLanguages: supportedWorkspaceLanguages
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.isVerticalApiProtocol = __webpack_exports__.isVerticalApiProtocol;
+exports.isVerticalPreset = __webpack_exports__.isVerticalPreset;
+exports.isWorkspaceDeliveryUnitKind = __webpack_exports__.isWorkspaceDeliveryUnitKind;
+exports.resolveOwnerAttribution = __webpack_exports__.resolveOwnerAttribution;
+exports.sortJsonValue = __webpack_exports__.sortJsonValue;
+exports.supportedWorkspaceLanguages = __webpack_exports__.supportedWorkspaceLanguages;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "isVerticalApiProtocol",
+    "isVerticalPreset",
+    "isWorkspaceDeliveryUnitKind",
+    "resolveOwnerAttribution",
+    "sortJsonValue",
+    "supportedWorkspaceLanguages"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});