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

package/dist/cjs/ultramodern-workspace/public-api.cjs

@@ -0,0 +1,58 @@
+"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__, {
+    addUltramodernShell: ()=>external_add_shell_cjs_namespaceObject.addUltramodernShell,
+    addUltramodernVertical: ()=>external_add_vertical_cjs_namespaceObject.addUltramodernVertical,
+    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
+});
+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_write_workspace_cjs_namespaceObject = require("./write-workspace.cjs");
+exports.addUltramodernShell = __webpack_exports__.addUltramodernShell;
+exports.addUltramodernVertical = __webpack_exports__.addUltramodernVertical;
+exports.generateUltramodernWorkspace = __webpack_exports__.generateUltramodernWorkspace;
+exports.normalizeUltramodernBridgeConfig = __webpack_exports__.normalizeUltramodernBridgeConfig;
+exports.planUltramodernShell = __webpack_exports__.planUltramodernShell;
+exports.planUltramodernVertical = __webpack_exports__.planUltramodernVertical;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "addUltramodernShell",
+    "addUltramodernVertical",
+    "generateUltramodernWorkspace",
+    "normalizeUltramodernBridgeConfig",
+    "planUltramodernShell",
+    "planUltramodernVertical"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/public-surface.cjs

@@ -0,0 +1,247 @@
+"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__, {
+    createLocalisedPublicPath: ()=>createLocalisedPublicPath,
+    createPublicSurfaceGenerationCommand: ()=>createPublicSurfaceGenerationCommand,
+    createPublicWebAppArtifacts: ()=>createPublicWebAppArtifacts,
+    publicSurfaceManagedSourceAssetPaths: ()=>publicSurfaceManagedSourceAssetPaths,
+    rewriteWorkspaceAssetsForApp: ()=>rewriteWorkspaceAssetsForApp,
+    uniqueSorted: ()=>uniqueSorted
+});
+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_app_files_cjs_namespaceObject = require("./app-files.cjs");
+const external_naming_cjs_namespaceObject = require("./naming.cjs");
+const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const external_routes_cjs_namespaceObject = require("./routes.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const publicSurfaceManagedSourceAssetPaths = [
+    'config/public/robots.txt',
+    'config/public/sitemap.xml',
+    'config/public/site.webmanifest'
+];
+const publicSurfaceBaseOutputFiles = [
+    'robots.txt'
+];
+const publicSurfacePublicRouteOutputFiles = [
+    'sitemap.xml',
+    'site.webmanifest'
+];
+function createLocalisedPublicPath(pathname, language) {
+    const publicPath = (0, external_routes_cjs_namespaceObject.normalisePublicPath)(pathname);
+    return '/' === publicPath ? `/${language}` : `/${language}${publicPath}`;
+}
+function uniqueSorted(values) {
+    return Array.from(new Set(values)).sort((left, right)=>left.localeCompare(right));
+}
+function createPublicSurfaceRouteEntries(app) {
+    return (0, external_routes_cjs_namespaceObject.createPublicRouteMetadata)(app).map((route)=>{
+        const localeUrlPaths = Object.fromEntries(external_types_cjs_namespaceObject.supportedWorkspaceLanguages.map((language)=>[
+                language,
+                createLocalisedPublicPath(route.localisedPaths[language], language)
+            ]));
+        if (!Object.values(localeUrlPaths).every(external_routes_cjs_namespaceObject.isConcretePublicPath)) return;
+        return {
+            ...route,
+            canonicalUrlPath: localeUrlPaths.en,
+            localeUrlPaths
+        };
+    }).filter((route)=>void 0 !== route).sort((left, right)=>left.canonicalUrlPath.localeCompare(right.canonicalUrlPath) || left.id.localeCompare(right.id));
+}
+function createPublicSurfaceUrlPaths(app) {
+    return uniqueSorted(createPublicSurfaceRouteEntries(app).flatMap((route)=>external_types_cjs_namespaceObject.supportedWorkspaceLanguages.map((language)=>route.localeUrlPaths[language])));
+}
+function createPublicSurfaceOutputFiles(app) {
+    return [
+        ...publicSurfaceBaseOutputFiles,
+        ...(0, external_routes_cjs_namespaceObject.createPublicRouteMetadata)(app).length > 0 ? publicSurfacePublicRouteOutputFiles : []
+    ];
+}
+function createPublicSurfaceGenerationCommand(app, target, requirePublicOrigin = false) {
+    return `node ${(0, external_naming_cjs_namespaceObject.relativeRootFor)(app.directory)}/scripts/generate-public-surface-assets.mts --app ${app.id} --target ${target}${requirePublicOrigin ? ' --require-public-origin' : ''}`;
+}
+function rewriteWorkspaceAssetsForApp(workspaceRoot, app) {
+    for (const relativePath of publicSurfaceManagedSourceAssetPaths)external_node_fs_default().rmSync(external_node_path_default().join(workspaceRoot, app.directory, relativePath), {
+        force: true
+    });
+}
+function createPublicSurfaceContract(app) {
+    const files = createPublicSurfaceOutputFiles(app);
+    const contentExpansionPolicy = (0, external_policy_cjs_namespaceObject.createPublicSurfaceContentExpansionPolicy)();
+    return {
+        authoring: 'colocated-route-meta',
+        artifactLifecycle: 'build-and-deploy-output',
+        generatedManifest: './src/routes/ultramodern-route-metadata',
+        source: 'route-owned-public-routes',
+        metadataExport: './src/routes/ultramodern-route-metadata',
+        generator: "scripts/generate-public-surface-assets.mts",
+        outputRoot: 'dist/public',
+        cloudflareBuildOutputRoot: 'dist-cloudflare/public',
+        privateRoutePolicy: 'omit-from-generated-public-surface',
+        files,
+        omittedByDefault: [
+            'api-catalog.json',
+            'llms.txt',
+            'security.txt'
+        ],
+        languages: [
+            ...external_types_cjs_namespaceObject.supportedWorkspaceLanguages
+        ],
+        contentExpansion: {
+            authoring: 'route-owned-esm-provider',
+            defaultProviderFile: contentExpansionPolicy.defaultProviderFile,
+            entryExport: 'default-or-entries',
+            paramsSource: 'params-or-localeParams',
+            draftPolicy: contentExpansionPolicy.draftPolicy,
+            indexablePolicy: contentExpansionPolicy.indexablePolicy,
+            lifecycle: 'executed-during-public-surface-generation'
+        },
+        contentSources: [],
+        publicRoutes: (0, external_routes_cjs_namespaceObject.createPublicRouteMetadata)(app),
+        routeEntries: createPublicSurfaceRouteEntries(app),
+        concreteUrlPaths: createPublicSurfaceUrlPaths(app)
+    };
+}
+function createPublicHeadContract() {
+    const robotsPolicy = (0, external_policy_cjs_namespaceObject.createPublicHeadRobotsPolicy)();
+    return {
+        authoring: 'colocated-route-meta',
+        generator: './src/routes/ultramodern-route-head',
+        renderer: '@modern-js/runtime/head Helmet',
+        ssr: true,
+        title: {
+            required: true,
+            source: 'route.titleKey'
+        },
+        description: {
+            required: true,
+            source: "route.descriptionKey"
+        },
+        canonical: {
+            publicIndexableOnly: true,
+            source: 'localized canonical route URL'
+        },
+        alternates: {
+            hreflang: [
+                ...external_types_cjs_namespaceObject.supportedWorkspaceLanguages
+            ],
+            xDefault: 'en'
+        },
+        openGraph: {
+            publicIndexableOnly: true,
+            required: [
+                'og:title',
+                "og:description",
+                'og:url',
+                'og:type'
+            ]
+        },
+        twitter: {
+            publicIndexableOnly: true,
+            required: [
+                'twitter:card',
+                'twitter:title',
+                "twitter:description"
+            ]
+        },
+        structuredData: {
+            publicIndexableOnly: true,
+            optional: true,
+            source: 'route.jsonLd',
+            inference: false,
+            helperModule: './src/routes/ultramodern-jsonld',
+            helperTypes: [
+                'WebPage',
+                'WebApplication',
+                'SoftwareApplication',
+                'BreadcrumbList',
+                'FAQPage',
+                'Organization'
+            ],
+            sanitizesHtmlOpenBracket: true
+        },
+        privateRouteRobots: robotsPolicy.privateRouteRobots
+    };
+}
+function createPublicWebAppArtifacts(app) {
+    const routeMetadata = (0, external_routes_cjs_namespaceObject.createRouteOwnedI18nPaths)(app);
+    return {
+        jsonLdHelperFile: {
+            path: `${app.directory}/src/routes/ultramodern-jsonld.ts`,
+            content: (0, external_routes_cjs_namespaceObject.createJsonLdHelperModule)()
+        },
+        routeMetadataFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-metadata.ts`,
+            content: (0, external_routes_cjs_namespaceObject.createRouteMetadataModule)(app)
+        },
+        routeHeadFile: {
+            path: `${app.directory}/src/routes/ultramodern-route-head.tsx`,
+            content: (0, external_app_files_cjs_namespaceObject.createRouteHeadModule)(app)
+        },
+        routeMetaFiles: routeMetadata.map((route)=>({
+                path: (0, external_routes_cjs_namespaceObject.createRouteMetaFilePath)(app, route.canonicalPath),
+                content: (0, external_routes_cjs_namespaceObject.createRouteMetaModule)(route)
+            })),
+        routeAliasFiles: routeMetadata.filter((route)=>'/' !== route.canonicalPath && 'shell' !== app.kind).map((route)=>({
+                path: (0, external_routes_cjs_namespaceObject.createRoutePageFilePath)(app, route.canonicalPath),
+                content: (0, external_routes_cjs_namespaceObject.createRouteAliasPage)(route.canonicalPath)
+            })),
+        publicHead: createPublicHeadContract(),
+        publicSurface: createPublicSurfaceContract(app)
+    };
+}
+exports.createLocalisedPublicPath = __webpack_exports__.createLocalisedPublicPath;
+exports.createPublicSurfaceGenerationCommand = __webpack_exports__.createPublicSurfaceGenerationCommand;
+exports.createPublicWebAppArtifacts = __webpack_exports__.createPublicWebAppArtifacts;
+exports.publicSurfaceManagedSourceAssetPaths = __webpack_exports__.publicSurfaceManagedSourceAssetPaths;
+exports.rewriteWorkspaceAssetsForApp = __webpack_exports__.rewriteWorkspaceAssetsForApp;
+exports.uniqueSorted = __webpack_exports__.uniqueSorted;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLocalisedPublicPath",
+    "createPublicSurfaceGenerationCommand",
+    "createPublicWebAppArtifacts",
+    "publicSurfaceManagedSourceAssetPaths",
+    "rewriteWorkspaceAssetsForApp",
+    "uniqueSorted"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,226 @@
+"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__, {
+    createJsonLdHelperModule: ()=>createJsonLdHelperModule,
+    createLocalisedUrlsMap: ()=>createLocalisedUrlsMap,
+    createPublicRouteMetadata: ()=>createPublicRouteMetadata,
+    createPublicRouteMetadataFromRoutes: ()=>createPublicRouteMetadataFromRoutes,
+    createRouteAliasPage: ()=>createRouteAliasPage,
+    createRouteMetaFilePath: ()=>createRouteMetaFilePath,
+    createRouteMetaModule: ()=>createRouteMetaModule,
+    createRouteMetadataModule: ()=>createRouteMetadataModule,
+    createRouteOwnedI18nPaths: ()=>createRouteOwnedI18nPaths,
+    createRoutePageFilePath: ()=>createRoutePageFilePath,
+    isConcretePublicPath: ()=>isConcretePublicPath,
+    normalisePublicPath: ()=>normalisePublicPath,
+    routePathParamName: ()=>routePathParamName,
+    routeSegmentToDirectory: ()=>routeSegmentToDirectory,
+    splitPublicPathSegments: ()=>splitPublicPathSegments
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_fs_io_cjs_namespaceObject = require("./fs-io.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const privateAppRoutePublicness = {
+    indexable: false,
+    public: false,
+    publicSurface: 'private-app-screen'
+};
+function createRouteOwnedI18nPaths(app) {
+    const namespace = (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app);
+    const base = {
+        descriptionKey: `${namespace}.seo.description`,
+        mfBoundaryId: app.mfName,
+        namespace,
+        ownerAppId: app.id,
+        ...privateAppRoutePublicness
+    };
+    if ('shell' === app.kind) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'shell-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'shell.title'
+        }
+    ];
+    return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: `${app.id}-home`,
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: `${namespace}.title`
+        }
+    ];
+}
+function isPublicIndexableRoute(route) {
+    return route.public && route.indexable;
+}
+function createLocalisedUrlsMapFromRoutes(routes) {
+    return Object.fromEntries(routes.flatMap((route)=>{
+        if ('/' === route.canonicalPath) return [];
+        return Array.from(new Set([
+            route.canonicalPath,
+            ...Object.values(route.localisedPaths)
+        ])).map((pathname)=>[
+                pathname,
+                route.localisedPaths
+            ]);
+    }));
+}
+function createLocalisedUrlsMap(app) {
+    return createLocalisedUrlsMapFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createPublicRouteMetadataFromRoutes(routes) {
+    return routes.filter(isPublicIndexableRoute).map((route)=>{
+        const metadata = {
+            canonicalPath: route.canonicalPath,
+            id: route.id,
+            localisedPaths: route.localisedPaths,
+            namespace: route.namespace,
+            ownerAppId: route.ownerAppId,
+            descriptionKey: route.descriptionKey,
+            titleKey: route.titleKey
+        };
+        if (void 0 !== route.jsonLd) metadata.jsonLd = route.jsonLd;
+        return metadata;
+    });
+}
+function createPublicRouteMetadata(app) {
+    return createPublicRouteMetadataFromRoutes(createRouteOwnedI18nPaths(app));
+}
+function createJsonLdHelperModule() {
+    return (0, external_fs_io_cjs_namespaceObject.renderFileTemplate)('workspace/apps/shared/src/routes/ultramodern-jsonld.ts', {});
+}
+function createRouteMetadataModule(app) {
+    const routes = (0, external_types_cjs_namespaceObject.sortJsonValue)(createRouteOwnedI18nPaths(app));
+    const localisedUrls = (0, external_types_cjs_namespaceObject.sortJsonValue)(createLocalisedUrlsMap(app));
+    const publicRoutes = (0, external_types_cjs_namespaceObject.sortJsonValue)(createPublicRouteMetadata(app));
+    const namespace = (0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app);
+    return (0, external_fs_io_cjs_namespaceObject.renderFileTemplate)('workspace/apps/shared/src/routes/ultramodern-route-metadata.ts', {
+        value0: namespace,
+        value1: JSON.stringify(routes, null, 2),
+        value2: JSON.stringify(localisedUrls, null, 2),
+        value3: JSON.stringify(publicRoutes, null, 2)
+    });
+}
+function createRouteMetaModule(route) {
+    return `const routeMeta = ${JSON.stringify((0, external_types_cjs_namespaceObject.sortJsonValue)(route), null, 2)} as const;
+
+export default routeMeta;
+export { routeMeta };
+`;
+}
+function normalisePublicPath(pathname) {
+    const normalised = pathname.trim().replaceAll(/\/+/gu, '/').replace(/\/+$/u, '');
+    return normalised.length > 0 && normalised.startsWith('/') ? normalised : `/${normalised}`;
+}
+function splitPublicPathSegments(pathname) {
+    return normalisePublicPath(pathname).split('/').filter(Boolean);
+}
+function routePathParamName(segment) {
+    if (segment.startsWith(':')) return segment.slice(1).replace(/[?*+]$/u, '');
+    if (segment.startsWith('[') && segment.endsWith(']')) return segment.slice(1, -1).replace(/^\.\.\./u, '').replace(/\$$/u, '');
+}
+function isDynamicPublicPathSegment(segment) {
+    return void 0 !== routePathParamName(segment) || segment.includes('*') || segment.startsWith('[');
+}
+function isConcretePublicPath(pathname) {
+    return !splitPublicPathSegments(pathname).some(isDynamicPublicPathSegment);
+}
+function routeSegmentToDirectory(segment) {
+    const paramName = routePathParamName(segment);
+    if (paramName && segment.startsWith(':')) return segment.endsWith('?') ? `[${paramName}$]` : `[${paramName}]`;
+    return segment;
+}
+function routePathDirectorySegments(routePath) {
+    return splitPublicPathSegments(routePath).map(routeSegmentToDirectory);
+}
+function createRoutePageFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'page.tsx'
+    ].join('/')}`;
+}
+function createRouteMetaFilePath(app, canonicalPath) {
+    const segments = routePathDirectorySegments(canonicalPath);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'route.meta.ts'
+    ].join('/')}`;
+}
+function createRouteAliasPage(canonicalPath) {
+    const depth = canonicalPath.split('/').filter(Boolean).length;
+    const rootPageImport = `${'../'.repeat(depth)}page`;
+    return `export { default } from '${rootPageImport}';
+`;
+}
+exports.createJsonLdHelperModule = __webpack_exports__.createJsonLdHelperModule;
+exports.createLocalisedUrlsMap = __webpack_exports__.createLocalisedUrlsMap;
+exports.createPublicRouteMetadata = __webpack_exports__.createPublicRouteMetadata;
+exports.createPublicRouteMetadataFromRoutes = __webpack_exports__.createPublicRouteMetadataFromRoutes;
+exports.createRouteAliasPage = __webpack_exports__.createRouteAliasPage;
+exports.createRouteMetaFilePath = __webpack_exports__.createRouteMetaFilePath;
+exports.createRouteMetaModule = __webpack_exports__.createRouteMetaModule;
+exports.createRouteMetadataModule = __webpack_exports__.createRouteMetadataModule;
+exports.createRouteOwnedI18nPaths = __webpack_exports__.createRouteOwnedI18nPaths;
+exports.createRoutePageFilePath = __webpack_exports__.createRoutePageFilePath;
+exports.isConcretePublicPath = __webpack_exports__.isConcretePublicPath;
+exports.normalisePublicPath = __webpack_exports__.normalisePublicPath;
+exports.routePathParamName = __webpack_exports__.routePathParamName;
+exports.routeSegmentToDirectory = __webpack_exports__.routeSegmentToDirectory;
+exports.splitPublicPathSegments = __webpack_exports__.splitPublicPathSegments;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createJsonLdHelperModule",
+    "createLocalisedUrlsMap",
+    "createPublicRouteMetadata",
+    "createPublicRouteMetadataFromRoutes",
+    "createRouteAliasPage",
+    "createRouteMetaFilePath",
+    "createRouteMetaModule",
+    "createRouteMetadataModule",
+    "createRouteOwnedI18nPaths",
+    "createRoutePageFilePath",
+    "isConcretePublicPath",
+    "normalisePublicPath",
+    "routePathParamName",
+    "routeSegmentToDirectory",
+    "splitPublicPathSegments"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/shared-patches.cjs

@@ -0,0 +1,41 @@
+"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__, {
+    SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES: ()=>SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES
+});
+const external_policy_cjs_namespaceObject = require("./policy.cjs");
+const SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = external_policy_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_POLICY.pnpm.patchedDependencies.required.map((patch)=>patch.path.replace(/^patches\//u, '')).filter((patchFile)=>patchFile.startsWith('@module-federation__') || patchFile.startsWith('@tanstack__') || patchFile.startsWith('msgpackr@') || patchFile.startsWith('zod@'));
+exports.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES = __webpack_exports__.SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SHARED_ULTRAMODERN_WORKSPACE_PATCH_FILES"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});