@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/cjs/plugins/deploy/platforms/cloudflare/delivery-unit.js

@@ -0,0 +1,118 @@
+"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__, {
+    resolveTopologyDeliveryUnit: ()=>resolveTopologyDeliveryUnit,
+    resolveWorkerDeliveryUnitStamp: ()=>resolveWorkerDeliveryUnitStamp
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const universal_namespaceObject = require("@modern-js/utils/universal");
+const external_utils_js_namespaceObject = require("./utils.js");
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = external_node_path_default().resolve(appDirectory);
+    for(;;){
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = external_node_path_default().dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveTopologyDeliveryUnit = async (appDirectory)=>{
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    let compactConfig;
+    try {
+        compactConfig = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
+    } catch  {
+        return;
+    }
+    if (!(0, external_utils_js_namespaceObject.isRecord)(compactConfig)) return;
+    const topology = (0, external_utils_js_namespaceObject.isRecord)(compactConfig.topology) ? compactConfig.topology : void 0;
+    const apps = Array.isArray(topology?.apps) ? topology.apps : [];
+    const resolvedAppDirectory = external_node_path_default().resolve(appDirectory);
+    for (const app of apps){
+        if (!(0, external_utils_js_namespaceObject.isRecord)(app)) continue;
+        const appPath = (0, universal_namespaceObject.nonEmptyString)(app.path);
+        if (appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) return (0, universal_namespaceObject.toDeliveryUnitIdentity)(app.deliveryUnit);
+    }
+    return (0, universal_namespaceObject.toDeliveryUnitIdentity)(compactConfig.deliveryUnit);
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildArtifactPath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
+    const buildModulePath = external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_MODULE_PATH);
+    let identity;
+    if (await utils_namespaceObject.fs.pathExists(buildArtifactPath)) {
+        const artifact = await utils_namespaceObject.fs.readJSON(buildArtifactPath);
+        if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) return;
+        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)(artifact.deliveryUnit);
+    } else if (await utils_namespaceObject.fs.pathExists(buildModulePath)) {
+        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
+        const source = await utils_namespaceObject.fs.readFile(buildModulePath, 'utf8');
+        identity = (0, universal_namespaceObject.toDeliveryUnitIdentity)({
+            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+        });
+    }
+    if (!identity) return;
+    return {
+        ...identity,
+        surfaces: {
+            ui: {
+                ...identity,
+                surface: 'ui'
+            },
+            api: {
+                ...identity,
+                surface: 'api'
+            }
+        }
+    };
+};
+exports.resolveTopologyDeliveryUnit = __webpack_exports__.resolveTopologyDeliveryUnit;
+exports.resolveWorkerDeliveryUnitStamp = __webpack_exports__.resolveWorkerDeliveryUnitStamp;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveTopologyDeliveryUnit",
+    "resolveWorkerDeliveryUnitStamp"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare/i18n-worker.js

@@ -0,0 +1,135 @@
+"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__, {
+    createI18nWorkerManifest: ()=>createI18nWorkerManifest
+});
+const external_utils_js_namespaceObject = require("./utils.js");
+const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupHeader: 'accept-language'
+};
+const SERVER_SIDE_I18N_DETECTORS = new Set([
+    'querystring',
+    'cookie',
+    'header'
+]);
+const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
+const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
+const removeLocaleDetectionByEntry = (config)=>{
+    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
+    return rest;
+};
+const getEntryLocaleDetection = (entryName, localeDetection)=>{
+    const byEntry = (0, external_utils_js_namespaceObject.isRecord)(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
+    const entryConfig = byEntry?.[entryName];
+    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
+    return (0, external_utils_js_namespaceObject.isRecord)(entryConfig) ? {
+        ...globalConfig,
+        ...entryConfig
+    } : globalConfig;
+};
+const normalizeI18nDetection = (detection)=>{
+    const configured = (0, external_utils_js_namespaceObject.isRecord)(detection) ? detection : {};
+    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
+    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
+    return {
+        order: order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ],
+        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
+        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
+        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
+    };
+};
+const normalizeLocalisedUrls = (localisedUrls)=>{
+    if (!(0, external_utils_js_namespaceObject.isRecord)(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
+    const normalized = {};
+    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
+        if (!(0, external_utils_js_namespaceObject.isRecord)(languageMap)) continue;
+        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
+        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+};
+const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
+    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
+    const languages = toStringArray(entryConfig.languages);
+    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
+    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
+    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
+    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
+    return {
+        i18nextDetector: false !== entryConfig.i18nextDetector,
+        languages,
+        fallbackLanguage,
+        detection: normalizeI18nDetection(entryConfig.detection),
+        ignoreRedirectRoutes,
+        staticRoutePrefixes,
+        ...localisedUrls ? {
+            localisedUrls
+        } : {}
+    };
+};
+const createI18nWorkerManifest = (routeSpec, appContext)=>{
+    const i18nServerPlugin = getI18nServerPlugin(appContext);
+    const localeDetection = i18nServerPlugin?.options?.localeDetection;
+    if (!(0, external_utils_js_namespaceObject.isRecord)(localeDetection)) return;
+    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
+    const entries = {};
+    for (const route of routeSpec.routes){
+        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
+        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
+        if (entry) entries[route.entryName] = entry;
+    }
+    return Object.keys(entries).length > 0 ? {
+        entries
+    } : void 0;
+};
+exports.createI18nWorkerManifest = __webpack_exports__.createI18nWorkerManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nWorkerManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare/index.js

@@ -0,0 +1,126 @@
+"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__, {
+    createCloudflarePreset: ()=>createCloudflarePreset
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../../utils/index.js");
+const external_cloudflare_output_plan_js_namespaceObject = require("../cloudflare-output-plan.js");
+const external_cloudflare_output_verifier_js_namespaceObject = require("../cloudflare-output-verifier.js");
+const external_artifacts_js_namespaceObject = require("./artifacts.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_delivery_unit_js_namespaceObject = require("./delivery-unit.js");
+const external_worker_manifest_js_namespaceObject = require("./worker-manifest.js");
+const external_wrangler_config_js_namespaceObject = require("./wrangler-config.js");
+const CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS = [
+    'cloudflare-entry.001-bootstrap-security.mjs',
+    'cloudflare-entry.002-assets-routes.mjs',
+    'cloudflare-entry.003-i18n-locales.mjs',
+    'cloudflare-entry.004-rendering-css.mjs',
+    'cloudflare-entry.005-worker-dispatch.mjs',
+    'cloudflare-entry.006-fetch-handler.mjs'
+];
+const readCloudflareEntryTemplate = async ()=>(await Promise.all(CLOUDFLARE_ENTRY_TEMPLATE_FRAGMENTS.map((fragment)=>(0, index_js_namespaceObject.readTemplate)(fragment)))).join('');
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { appDirectory, distDirectory } = appContext;
+    const outputDirectory = external_node_path_default().join(appDirectory, '.output');
+    const outputPlan = (0, external_cloudflare_output_plan_js_namespaceObject.createCloudflareOutputPlan)(outputDirectory);
+    const publicDirectory = outputPlan.paths.publicAssets;
+    const workerEntryPath = outputPlan.paths.workerEntry;
+    const workerManifestPath = outputPlan.paths.workerManifest;
+    const routeSpecOutputPath = external_node_path_default().join(outputDirectory, external_constants_js_namespaceObject.ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = outputPlan.paths.wranglerConfig;
+    const cloudflareArtifacts = (0, external_artifacts_js_namespaceObject.getCloudflareArtifacts)(modernConfig);
+    const publicAssetExcludes = (0, external_worker_manifest_js_namespaceObject.getPublicAssetExcludes)(appDirectory, modernConfig);
+    return {
+        async prepare () {
+            await utils_namespaceObject.fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>(0, external_worker_manifest_js_namespaceObject.shouldCopyToPublicAssets)(src, distDirectory, publicAssetExcludes)
+            });
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerEntryPath));
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerManifestPath));
+            const routeSpecSourcePath = external_node_path_default().join(distDirectory, external_constants_js_namespaceObject.ROUTE_SPEC_FILE);
+            if (await utils_namespaceObject.fs.pathExists(routeSpecSourcePath)) await utils_namespaceObject.fs.copy(routeSpecSourcePath, routeSpecOutputPath);
+            const workerBundleSourceDirectory = external_node_path_default().join(distDirectory, external_constants_js_namespaceObject.WORKER_BUNDLE_DIRECTORY);
+            const workerBundleOutputDirectory = outputPlan.paths.workerBundle;
+            if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) {
+                await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
+                    filter: (src)=>(0, external_worker_manifest_js_namespaceObject.shouldCopyToWorkerBundle)(src, workerBundleSourceDirectory)
+                });
+                await utils_namespaceObject.fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
+            }
+            await (0, external_artifacts_js_namespaceObject.copyCloudflareArtifacts)(appDirectory, outputDirectory, cloudflareArtifacts);
+            await (0, external_artifacts_js_namespaceObject.copyCloudflarePublicAssets)(appDirectory, publicDirectory, (0, external_artifacts_js_namespaceObject.getCloudflarePublicAssets)(modernConfig));
+            await (0, external_artifacts_js_namespaceObject.copyCloudflareD1Migrations)(appDirectory, outputDirectory, modernConfig);
+            await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, (0, external_wrangler_config_js_namespaceObject.createWranglerConfig)(appDirectory, modernConfig), {
+                spaces: 2
+            });
+            const deliveryUnitStamp = await (0, external_delivery_unit_js_namespaceObject.resolveWorkerDeliveryUnitStamp)(appDirectory);
+            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await (0, external_worker_manifest_js_namespaceObject.createWorkerManifest)(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
+                spaces: 2
+            });
+            await utils_namespaceObject.fs.writeJSON(outputPlan.paths.outputPackage, outputPlan.packages.output);
+        },
+        async genEntry () {
+            const template = await readCloudflareEntryTemplate();
+            const manifest = await utils_namespaceObject.fs.readJSON(workerManifestPath);
+            await utils_namespaceObject.fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', (0, external_worker_manifest_js_namespaceObject.createWorkerModuleLoaders)(manifest)));
+            const topologyDeliveryUnit = await (0, external_delivery_unit_js_namespaceObject.resolveTopologyDeliveryUnit)(appDirectory);
+            await (0, external_cloudflare_output_verifier_js_namespaceObject.assertCloudflareOutput)({
+                outputDirectory,
+                importWorker: false,
+                ...topologyDeliveryUnit ? {
+                    deliveryUnit: topologyDeliveryUnit
+                } : {}
+            });
+        }
+    };
+};
+exports.createCloudflarePreset = __webpack_exports__.createCloudflarePreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCloudflarePreset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare/security-policies.js

@@ -0,0 +1,223 @@
+"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 DEFAULT_SECURITY_HEADERS = {
+    referrerPolicy: 'strict-origin-when-cross-origin',
+    contentTypeOptions: 'nosniff',
+    permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
+};
+const DEFAULT_CORS_ALLOWED_METHODS = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS'
+];
+const DEFAULT_CSP_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:'
+    ]
+};
+const normalizeDirectiveValues = (value)=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return [
+        ...new Set(values.map((entry)=>entry.trim()).filter(Boolean))
+    ];
+};
+const appendDirectiveValues = (directives, name, values)=>{
+    if (!values?.length) return;
+    directives[name] = normalizeDirectiveValues([
+        ...directives[name] ?? [],
+        ...values
+    ]);
+};
+const createContentSecurityPolicy = (config)=>{
+    const mode = config?.mode ?? 'report-only';
+    if ('off' === mode) return {
+        mode,
+        directives: {},
+        reason: config?.reason
+    };
+    const directives = Object.fromEntries(Object.entries(DEFAULT_CSP_DIRECTIVES).map(([name, values])=>[
+            name,
+            [
+                ...values
+            ]
+        ]));
+    for (const [name, value] of Object.entries(config?.directives ?? {}))if (false === value) delete directives[name];
+    else directives[name] = normalizeDirectiveValues(value);
+    if (config?.frameAncestors === false) delete directives['frame-ancestors'];
+    else if (config?.frameAncestors) directives['frame-ancestors'] = normalizeDirectiveValues(config.frameAncestors);
+    appendDirectiveValues(directives, "script-src", config?.additionalScriptSrc);
+    appendDirectiveValues(directives, 'style-src', config?.additionalStyleSrc);
+    appendDirectiveValues(directives, 'connect-src', config?.additionalConnectSrc);
+    appendDirectiveValues(directives, 'img-src', config?.additionalImgSrc);
+    if (config?.reportUri) directives['report-uri'] = [
+        config.reportUri
+    ];
+    return {
+        mode,
+        directives,
+        reason: config?.reason
+    };
+};
+const createNoindexPolicy = (noindex)=>{
+    if (false === noindex) return {
+        workersDev: false,
+        localhost: false,
+        previewHostnames: []
+    };
+    if (true === noindex || void 0 === noindex) return {
+        workersDev: true,
+        localhost: true,
+        previewHostnames: []
+    };
+    return {
+        workersDev: noindex.workersDev ?? true,
+        localhost: noindex.localhost ?? true,
+        previewHostnames: noindex.previewHostnames ?? [],
+        reason: noindex.reason
+    };
+};
+const createCloudflareWorkerCorsPolicy = (cors)=>({
+        assets: cors?.assets ?? true,
+        allowedOrigins: normalizeDirectiveValues(cors?.allowedOrigins ?? []),
+        allowedMethods: cors?.allowedMethods?.length ? normalizeDirectiveValues(cors.allowedMethods.map((method)=>method.toUpperCase())) : DEFAULT_CORS_ALLOWED_METHODS,
+        allowedHeaders: cors?.allowedHeaders?.length ? normalizeDirectiveValues(cors.allowedHeaders) : [
+            '*'
+        ],
+        reason: cors?.reason
+    });
+const createCloudflareWorkerSecurityPolicy = (modernConfig)=>{
+    const security = modernConfig.deploy?.worker?.security;
+    if (security?.enabled === false) return {
+        enabled: false,
+        cors: createCloudflareWorkerCorsPolicy(security.cors),
+        reason: security.reason
+    };
+    return {
+        enabled: true,
+        headers: {
+            referrerPolicy: security?.headers?.referrerPolicy ?? DEFAULT_SECURITY_HEADERS.referrerPolicy,
+            contentTypeOptions: security?.headers?.contentTypeOptions ?? DEFAULT_SECURITY_HEADERS.contentTypeOptions,
+            permissionsPolicy: security?.headers?.permissionsPolicy ?? DEFAULT_SECURITY_HEADERS.permissionsPolicy
+        },
+        contentSecurityPolicy: createContentSecurityPolicy(security?.contentSecurityPolicy),
+        noindex: createNoindexPolicy(security?.noindex),
+        cors: createCloudflareWorkerCorsPolicy(security?.cors),
+        reason: security?.reason
+    };
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    DEFAULT_CORS_ALLOWED_METHODS: DEFAULT_CORS_ALLOWED_METHODS,
+    DEFAULT_CSP_DIRECTIVES: DEFAULT_CSP_DIRECTIVES,
+    DEFAULT_SECURITY_HEADERS: DEFAULT_SECURITY_HEADERS,
+    createCloudflareWorkerCorsPolicy: createCloudflareWorkerCorsPolicy,
+    createCloudflareWorkerSecurityPolicy: createCloudflareWorkerSecurityPolicy,
+    createContentSecurityPolicy: createContentSecurityPolicy,
+    createNoindexPolicy: createNoindexPolicy
+});
+exports.DEFAULT_CORS_ALLOWED_METHODS = __webpack_exports__.DEFAULT_CORS_ALLOWED_METHODS;
+exports.DEFAULT_CSP_DIRECTIVES = __webpack_exports__.DEFAULT_CSP_DIRECTIVES;
+exports.DEFAULT_SECURITY_HEADERS = __webpack_exports__.DEFAULT_SECURITY_HEADERS;
+exports.createCloudflareWorkerCorsPolicy = __webpack_exports__.createCloudflareWorkerCorsPolicy;
+exports.createCloudflareWorkerSecurityPolicy = __webpack_exports__.createCloudflareWorkerSecurityPolicy;
+exports.createContentSecurityPolicy = __webpack_exports__.createContentSecurityPolicy;
+exports.createNoindexPolicy = __webpack_exports__.createNoindexPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_CORS_ALLOWED_METHODS",
+    "DEFAULT_CSP_DIRECTIVES",
+    "DEFAULT_SECURITY_HEADERS",
+    "createCloudflareWorkerCorsPolicy",
+    "createCloudflareWorkerSecurityPolicy",
+    "createContentSecurityPolicy",
+    "createNoindexPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/platforms/cloudflare/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});