@bleedingdev/modern-js-create 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

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

@@ -0,0 +1,248 @@
+"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__, {
+    PUBLIC_WEBSITE_POLICY: ()=>PUBLIC_WEBSITE_POLICY,
+    createCloudflareDeployContract: ()=>createCloudflareDeployContract,
+    createCloudflareProofRoute: ()=>createCloudflareProofRoute,
+    createCloudflareSecurityContract: ()=>createCloudflareSecurityContract,
+    createPublicHeadRobotsPolicy: ()=>createPublicHeadRobotsPolicy,
+    createPublicSurfaceContentExpansionPolicy: ()=>createPublicSurfaceContentExpansionPolicy,
+    createPublicWebsiteBudgetFallback: ()=>createPublicWebsiteBudgetFallback,
+    createPublicWebsiteQualityGateContract: ()=>createPublicWebsiteQualityGateContract,
+    formatIntegerCodeLiteral: ()=>formatIntegerCodeLiteral,
+    formatTsJsonValue: ()=>formatTsJsonValue
+});
+const external_descriptors_cjs_namespaceObject = require("./descriptors.cjs");
+const external_routes_cjs_namespaceObject = require("./routes.cjs");
+const external_types_cjs_namespaceObject = require("./types.cjs");
+const external_versions_cjs_namespaceObject = require("./versions.cjs");
+function createCloudflareProofRoute(app) {
+    if ('shell' === app.kind) return {
+        ssr: '/en',
+        mfManifest: '/mf-manifest.json',
+        locale: `/locales/en/${(0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app)}.json`
+    };
+    const languageRoutes = (0, external_routes_cjs_namespaceObject.createLocalisedUrlsMap)(app);
+    const firstCanonicalPath = Object.keys(languageRoutes)[0];
+    const localizedPath = firstCanonicalPath && (0, external_types_cjs_namespaceObject.isRecord)(languageRoutes[firstCanonicalPath]) ? languageRoutes[firstCanonicalPath].en : void 0;
+    return {
+        ssr: localizedPath ?? '/en',
+        mfManifest: '/mf-manifest.json',
+        locale: `/locales/en/${(0, external_descriptors_cjs_namespaceObject.appI18nNamespace)(app)}.json`,
+        ...(0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? {
+            effectReadiness: `${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(app)}/effect/${(0, external_descriptors_cjs_namespaceObject.effectApiStem)(app)}/readiness`
+        } : {}
+    };
+}
+function createCloudflareSecurityContract() {
+    return {
+        enabled: true,
+        headers: {
+            referrerPolicy: 'strict-origin-when-cross-origin',
+            contentTypeOptions: 'nosniff',
+            permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
+        },
+        contentSecurityPolicy: {
+            mode: 'report-only',
+            directives: {
+                'base-uri': [
+                    "'self'"
+                ],
+                'connect-src': [
+                    "'self'",
+                    'https:',
+                    'http:',
+                    'wss:',
+                    'ws:'
+                ],
+                'default-src': [
+                    "'self'"
+                ],
+                'font-src': [
+                    "'self'",
+                    'data:',
+                    'https:',
+                    'http:'
+                ],
+                'form-action': [
+                    "'self'"
+                ],
+                'frame-ancestors': [
+                    "'self'"
+                ],
+                'img-src': [
+                    "'self'",
+                    'data:',
+                    'blob:',
+                    'https:',
+                    'http:'
+                ],
+                'manifest-src': [
+                    "'self'",
+                    'https:',
+                    'http:'
+                ],
+                'object-src': [
+                    "'none'"
+                ],
+                "script-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "'unsafe-eval'",
+                    'https:',
+                    'http:',
+                    'blob:'
+                ],
+                'style-src': [
+                    "'self'",
+                    "'unsafe-inline'",
+                    'https:',
+                    'http:'
+                ],
+                'worker-src': [
+                    "'self'",
+                    'blob:'
+                ]
+            },
+            reason: "Report-only by default so Cloudflare Module Federation SSR can prove remote script, style, and connect compatibility before enforcement."
+        },
+        noindex: {
+            workersDev: true,
+            localhost: true,
+            previewHostnames: []
+        }
+    };
+}
+const PUBLIC_WEBSITE_POLICY = {
+    qualityGates: {
+        publicRoutes: {
+            requireSitemapWhenPresent: true,
+            requireRobotsSitemapConsistency: true,
+            requireWebManifestWhenPresent: true
+        },
+        statusCodes: {
+            notFoundRoute: '/__ultramodern-smoke-missing',
+            unknownRouteStatus: 404
+        },
+        indexing: {
+            previewNoindex: true,
+            productionPublicRoutesIndexable: true
+        },
+        assets: {
+            cssPreloadRequired: true,
+            cssResponseRequired: true,
+            cacheControlRequiredForCss: true,
+            sourcemapsPubliclyReferenced: false
+        },
+        budgets: {
+            ssrHtmlMaxBytes: 250000,
+            mfManifestMaxBytes: 500000,
+            localeJsonMaxBytes: 100000,
+            sitemapXmlMaxBytes: 500000,
+            cssAssetMaxBytes: 750000
+        },
+        csp: {
+            finalMode: 'report-only-dogfood',
+            decision: "Report-only remains the generated final mode until public smoke proof records MF SSR script/style/connect compatibility for the deployed surface."
+        }
+    },
+    publicHead: {
+        indexableRobots: 'index, follow',
+        privateRouteRobots: 'noindex, nofollow'
+    },
+    publicSurface: {
+        defaultProviderFile: 'route.sitemap.mjs',
+        draftPolicy: 'omit-draft-by-default',
+        indexablePolicy: 'omit-indexable-false'
+    }
+};
+function formatTsJsonValue(value, indent) {
+    return JSON.stringify(value, null, 2).replaceAll('\n', `\n${' '.repeat(indent)}`);
+}
+function formatIntegerCodeLiteral(value) {
+    return String(value).replace(/\B(?=(\d{3})+(?!\d))/gu, '_');
+}
+function createPublicWebsiteQualityGateContract() {
+    return PUBLIC_WEBSITE_POLICY.qualityGates;
+}
+function createPublicWebsiteBudgetFallback(budgetName) {
+    return formatIntegerCodeLiteral(PUBLIC_WEBSITE_POLICY.qualityGates.budgets[budgetName]);
+}
+function createPublicHeadRobotsPolicy() {
+    return PUBLIC_WEBSITE_POLICY.publicHead;
+}
+function createPublicSurfaceContentExpansionPolicy() {
+    return PUBLIC_WEBSITE_POLICY.publicSurface;
+}
+function createCloudflareDeployContract(scope, app) {
+    return {
+        target: 'cloudflare',
+        workerName: (0, external_descriptors_cjs_namespaceObject.createCloudflareWorkerName)(scope, app),
+        publicUrlEnv: (0, external_descriptors_cjs_namespaceObject.createCloudflarePublicUrlEnv)(app),
+        compatibilityDate: external_versions_cjs_namespaceObject.CLOUDFLARE_COMPATIBILITY_DATE,
+        compatibilityFlags: [
+            'nodejs_compat',
+            'global_fetch_strictly_public'
+        ],
+        assetsBinding: 'ASSETS',
+        routes: createCloudflareProofRoute(app),
+        security: createCloudflareSecurityContract(),
+        qualityGates: createPublicWebsiteQualityGateContract(),
+        evidence: {
+            proofScript: "scripts/proof-cloudflare-version.mjs",
+            reportDefault: '.codex/reports/cloudflare-version-proof/public-url-proof.json'
+        }
+    };
+}
+exports.PUBLIC_WEBSITE_POLICY = __webpack_exports__.PUBLIC_WEBSITE_POLICY;
+exports.createCloudflareDeployContract = __webpack_exports__.createCloudflareDeployContract;
+exports.createCloudflareProofRoute = __webpack_exports__.createCloudflareProofRoute;
+exports.createCloudflareSecurityContract = __webpack_exports__.createCloudflareSecurityContract;
+exports.createPublicHeadRobotsPolicy = __webpack_exports__.createPublicHeadRobotsPolicy;
+exports.createPublicSurfaceContentExpansionPolicy = __webpack_exports__.createPublicSurfaceContentExpansionPolicy;
+exports.createPublicWebsiteBudgetFallback = __webpack_exports__.createPublicWebsiteBudgetFallback;
+exports.createPublicWebsiteQualityGateContract = __webpack_exports__.createPublicWebsiteQualityGateContract;
+exports.formatIntegerCodeLiteral = __webpack_exports__.formatIntegerCodeLiteral;
+exports.formatTsJsonValue = __webpack_exports__.formatTsJsonValue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PUBLIC_WEBSITE_POLICY",
+    "createCloudflareDeployContract",
+    "createCloudflareProofRoute",
+    "createCloudflareSecurityContract",
+    "createPublicHeadRobotsPolicy",
+    "createPublicSurfaceContentExpansionPolicy",
+    "createPublicWebsiteBudgetFallback",
+    "createPublicWebsiteQualityGateContract",
+    "formatIntegerCodeLiteral",
+    "formatTsJsonValue"
+].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,268 @@
+"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,
+    createPublicHeadContract: ()=>createPublicHeadContract,
+    createPublicSurfaceContract: ()=>createPublicSurfaceContract,
+    createPublicSurfaceGenerationCommand: ()=>createPublicSurfaceGenerationCommand,
+    createPublicSurfaceOutputFiles: ()=>createPublicSurfaceOutputFiles,
+    createPublicSurfaceRouteEntries: ()=>createPublicSurfaceRouteEntries,
+    createPublicSurfaceUrlPaths: ()=>createPublicSurfaceUrlPaths,
+    createPublicWebAppArtifacts: ()=>createPublicWebAppArtifacts,
+    publicSurfaceBaseOutputFiles: ()=>publicSurfaceBaseOutputFiles,
+    publicSurfaceManagedSourceAssetPaths: ()=>publicSurfaceManagedSourceAssetPaths,
+    publicSurfacePublicRouteOutputFiles: ()=>publicSurfacePublicRouteOutputFiles,
+    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.mjs --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.mjs",
+        outputRoot: 'dist/public',
+        cloudflareOutputRoot: '.output/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.createPublicHeadContract = __webpack_exports__.createPublicHeadContract;
+exports.createPublicSurfaceContract = __webpack_exports__.createPublicSurfaceContract;
+exports.createPublicSurfaceGenerationCommand = __webpack_exports__.createPublicSurfaceGenerationCommand;
+exports.createPublicSurfaceOutputFiles = __webpack_exports__.createPublicSurfaceOutputFiles;
+exports.createPublicSurfaceRouteEntries = __webpack_exports__.createPublicSurfaceRouteEntries;
+exports.createPublicSurfaceUrlPaths = __webpack_exports__.createPublicSurfaceUrlPaths;
+exports.createPublicWebAppArtifacts = __webpack_exports__.createPublicWebAppArtifacts;
+exports.publicSurfaceBaseOutputFiles = __webpack_exports__.publicSurfaceBaseOutputFiles;
+exports.publicSurfaceManagedSourceAssetPaths = __webpack_exports__.publicSurfaceManagedSourceAssetPaths;
+exports.publicSurfacePublicRouteOutputFiles = __webpack_exports__.publicSurfacePublicRouteOutputFiles;
+exports.rewriteWorkspaceAssetsForApp = __webpack_exports__.rewriteWorkspaceAssetsForApp;
+exports.uniqueSorted = __webpack_exports__.uniqueSorted;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLocalisedPublicPath",
+    "createPublicHeadContract",
+    "createPublicSurfaceContract",
+    "createPublicSurfaceGenerationCommand",
+    "createPublicSurfaceOutputFiles",
+    "createPublicSurfaceRouteEntries",
+    "createPublicSurfaceUrlPaths",
+    "createPublicWebAppArtifacts",
+    "publicSurfaceBaseOutputFiles",
+    "publicSurfaceManagedSourceAssetPaths",
+    "publicSurfacePublicRouteOutputFiles",
+    "rewriteWorkspaceAssetsForApp",
+    "uniqueSorted"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});