@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.9 → 3.2.0-ultramodern.91

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -0,0 +1,438 @@
+const ASSETS_BINDING = 'ASSETS';
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
+const workerModulePromises = new Map();
+const remoteJsonPromises = new Map();
+const CORS_HEADERS = {
+    'access-control-allow-headers': '*',
+    'access-control-allow-methods': 'GET, HEAD, OPTIONS',
+    'access-control-allow-origin': '*'
+};
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';
+function withCorsHeaders(response) {
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(CORS_HEADERS))if (!headers.has(name)) headers.set(name, value);
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+function isFingerprintedAssetPathname(pathname) {
+    return /(?:^|\/)[^/]+\.[a-f0-9]{8,}\.(?:css|js|mjs|json|svg|png|jpe?g|webp|avif|gif|woff2?|ttf)$/iu.test(pathname);
+}
+function withAssetHeaders(response, request) {
+    const corsResponse = withCorsHeaders(response);
+    const headers = new Headers(corsResponse.headers);
+    const { pathname } = new URL(request.url);
+    if (isFingerprintedAssetPathname(pathname)) headers.set('cache-control', 'public, max-age=31536000, immutable');
+    return new Response(corsResponse.body, {
+        headers,
+        status: corsResponse.status,
+        statusText: corsResponse.statusText
+    });
+}
+function createCorsPreflightResponse(request) {
+    if ('OPTIONS' !== request.method) return null;
+    return new Response(null, {
+        headers: CORS_HEADERS,
+        status: 204
+    });
+}
+async function fetchAsset(request, env) {
+    const assets = env?.[ASSETS_BINDING];
+    if (!assets || 'function' != typeof assets.fetch) return null;
+    const response = await assets.fetch(request);
+    if (404 === response.status) return null;
+    return withAssetHeaders(response, request);
+}
+async function fetchAssetByPath(pathname, request, env) {
+    const url = new URL(request.url);
+    url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
+    return fetchAsset(new Request(url, request), env);
+}
+async function fetchAssetByPathFollowingRedirects(pathname, request, env, visited = new Set()) {
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    if (visited.has(normalizedPathname)) return null;
+    visited.add(normalizedPathname);
+    const response = await fetchAssetByPath(normalizedPathname, request, env);
+    if (response && response.status >= 300 && response.status < 400 && response.headers.has('location')) {
+        const location = response.headers.get('location');
+        if (location) {
+            const nextUrl = new URL(location, request.url);
+            const currentUrl = new URL(request.url);
+            if (nextUrl.origin === currentUrl.origin) return fetchAssetByPathFollowingRedirects(nextUrl.pathname, request, env, visited);
+        }
+    }
+    return response;
+}
+async function readAssetText(pathname, request, env) {
+    const response = await fetchAssetByPathFollowingRedirects(pathname, request, env);
+    if (!response || !response.ok) return;
+    return response.text();
+}
+async function readAssetJson(pathname, request, env) {
+    const text = await readAssetText(pathname, request, env);
+    if (!text) return {};
+    return JSON.parse(text);
+}
+function normalizeRoutePath(pathname) {
+    if ('/' === pathname) return pathname;
+    return pathname.replace(/\/+$/u, '');
+}
+function getPathExtension(pathname) {
+    const lastSegment = pathname.split('/').pop() || '';
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (dotIndex <= 0 || dotIndex === lastSegment.length - 1) return '';
+    return lastSegment.slice(dotIndex).toLowerCase();
+}
+function isAssetLikePathname(pathname) {
+    const extension = getPathExtension(pathname);
+    return '' !== extension && '.html' !== extension && '.htm' !== extension;
+}
+function routeMatchesExactly(route, pathname) {
+    if ('string' != typeof route?.urlPath) return false;
+    return normalizeRoutePath(route.urlPath) === normalizeRoutePath(pathname);
+}
+function routeMatches(route, pathname) {
+    if ('string' != typeof route.urlPath) return false;
+    const routePath = normalizeRoutePath(route.urlPath);
+    const requestPath = normalizeRoutePath(pathname);
+    return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
+}
+function findRoute(request) {
+    const { pathname } = new URL(request.url);
+    const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
+    return [
+        ...routes
+    ].sort((left, right)=>{
+        const leftLength = left.urlPath?.length || 0;
+        const rightLength = right.urlPath?.length || 0;
+        return rightLength - leftLength;
+    }).find((route)=>routeMatches(route, pathname));
+}
+async function fetchRouteHtml(route, request, env) {
+    if (!route?.entryPath) return null;
+    return fetchAssetByPath(route.entryPath, request, env);
+}
+function createNoopMonitors() {
+    const noop = ()=>{};
+    return {
+        debug: noop,
+        error: noop,
+        info: noop,
+        warn: noop
+    };
+}
+function createRequestHandlerOptions({ route, htmlTemplate, routeManifest, loadableStats }) {
+    const monitors = createNoopMonitors();
+    return {
+        resource: {
+            route,
+            routeManifest,
+            loadableStats,
+            htmlTemplate,
+            entryName: route.entryName
+        },
+        params: {},
+        loaderContext: {},
+        config: {},
+        locals: {},
+        staticGenerate: false,
+        monitors,
+        onError (error) {
+            monitors.error(error);
+        },
+        onTiming () {},
+        reporter: {
+            reportTiming: ()=>{}
+        }
+    };
+}
+function collectRouteCssAssets(route, routeManifest) {
+    const routeAssets = routeManifest?.routeAssets || {};
+    const candidateKeys = [
+        route.entryName,
+        `async-${route.entryName}`
+    ].filter(Boolean);
+    const assets = new Set();
+    for (const key of candidateKeys){
+        const routeAsset = routeAssets[key];
+        const cssAssets = [
+            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
+            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
+        ];
+        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
+    }
+    return [
+        ...assets
+    ];
+}
+function collectRenderedFederatedExposes(html) {
+    const renderedExposes = [];
+    const tagPattern = /<[^>]*data-modern-(?:boundary-id|mf-expose)=["'][^"']+["'][^>]*>/g;
+    const attributePattern = /\s(data-modern-(?:boundary-id|mf-expose))=["']([^"']+)["']/g;
+    for (const [tag] of html.matchAll(tagPattern)){
+        const attributes = {};
+        for (const [, name, value] of tag.matchAll(attributePattern))attributes[name] = value;
+        const boundaryId = attributes['data-modern-boundary-id'];
+        const expose = attributes['data-modern-mf-expose'];
+        if (boundaryId && expose) renderedExposes.push({
+            boundaryId,
+            expose
+        });
+    }
+    return renderedExposes;
+}
+function getRemoteManifestUrl(remote, request) {
+    const entry = remote?.entry;
+    if ('string' != typeof entry || 0 === entry.length) return;
+    return new URL(entry, request.url).toString();
+}
+async function fetchRemoteJson(jsonUrl) {
+    if (!remoteJsonPromises.has(jsonUrl)) remoteJsonPromises.set(jsonUrl, fetch(jsonUrl).then((response)=>{
+        if (!response.ok) {
+            remoteJsonPromises.delete(jsonUrl);
+            return {};
+        }
+        return response.json().catch(()=>{
+            remoteJsonPromises.delete(jsonUrl);
+            return {};
+        });
+    }).catch(()=>{
+        remoteJsonPromises.delete(jsonUrl);
+        return {};
+    }));
+    return remoteJsonPromises.get(jsonUrl);
+}
+function findRemoteExpose(remoteManifest, exposePath) {
+    const exposes = Array.isArray(remoteManifest?.exposes) ? remoteManifest.exposes : [];
+    const normalizedExpose = exposePath.replace(/^\.\//u, '');
+    return exposes.find((expose)=>{
+        if (!expose || 'object' != typeof expose) return false;
+        return expose.path === exposePath || expose.path === `./${normalizedExpose}` || expose.name === normalizedExpose;
+    });
+}
+function collectCssAssetEntries(assets) {
+    const cssAssets = assets?.css;
+    return [
+        ...Array.isArray(cssAssets?.sync) ? cssAssets.sync : [],
+        ...Array.isArray(cssAssets?.async) ? cssAssets.async : []
+    ].filter((asset)=>'string' == typeof asset && asset.endsWith('.css'));
+}
+function collectRouteManifestCssAssets(routeManifest) {
+    const routeAssets = routeManifest?.routeAssets || {};
+    const assets = new Set();
+    for (const routeAsset of Object.values(routeAssets)){
+        const cssAssets = [
+            ...Array.isArray(routeAsset?.referenceCssAssets) ? routeAsset.referenceCssAssets : [],
+            ...Array.isArray(routeAsset?.assets) ? routeAsset.assets : []
+        ];
+        for (const asset of cssAssets)if ('string' == typeof asset && asset.endsWith('.css')) assets.add(asset);
+    }
+    return [
+        ...assets
+    ];
+}
+async function collectRenderedRemoteCssHrefs(html, request, env) {
+    const renderedExposes = collectRenderedFederatedExposes(html);
+    if (0 === renderedExposes.length) return [];
+    const hostManifest = await readAssetJson('mf-manifest.json', request, env);
+    const remotes = Array.isArray(hostManifest?.remotes) ? hostManifest.remotes : [];
+    const remoteByBoundary = new Map();
+    const hrefs = new Set();
+    for (const remote of remotes){
+        if ('string' == typeof remote?.alias) remoteByBoundary.set(remote.alias, remote);
+        if ('string' == typeof remote?.federationContainerName) remoteByBoundary.set(remote.federationContainerName, remote);
+    }
+    await Promise.all(renderedExposes.map(async ({ boundaryId, expose })=>{
+        const remote = remoteByBoundary.get(boundaryId);
+        const manifestUrl = remote ? getRemoteManifestUrl(remote, request) : void 0;
+        if (!manifestUrl) return;
+        const remoteManifest = await fetchRemoteJson(manifestUrl);
+        const remoteExpose = findRemoteExpose(remoteManifest, expose);
+        const publicPath = 'string' == typeof remoteManifest?.metaData?.publicPath ? remoteManifest.metaData.publicPath : manifestUrl;
+        const remoteRouteManifest = await fetchRemoteJson(new URL('routes-manifest.json', publicPath).toString());
+        for (const asset of collectCssAssetEntries(remoteExpose?.assets))hrefs.add(new URL(asset, publicPath).toString());
+        for (const asset of collectRouteManifestCssAssets(remoteRouteManifest))hrefs.add(new URL(asset, publicPath).toString());
+    }));
+    return [
+        ...hrefs
+    ];
+}
+function escapeAttribute(value) {
+    return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+async function withRouteCssLinks(response, route, routeManifest, request, env) {
+    const contentType = response.headers.get('content-type') || '';
+    if (!contentType.includes('text/html')) return response;
+    const html = await response.text();
+    const cssHrefs = [
+        ...collectRouteCssAssets(route, routeManifest).map((asset)=>new URL(asset, request.url).toString()),
+        ...await collectRenderedRemoteCssHrefs(html, request, env)
+    ];
+    if (0 === cssHrefs.length) return response;
+    const uniqueCssHrefs = [
+        ...new Set(cssHrefs)
+    ];
+    const headers = new Headers(response.headers);
+    for (const href of uniqueCssHrefs)headers.append('link', `<${href}>; rel=preload; as=style`);
+    const links = uniqueCssHrefs.filter((href)=>!html.includes(href)).map((href)=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
+    if (0 === links.length || !html.includes('</head>')) return new Response(html, {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+    return new Response(html.replace('</head>', `${links.join('')}</head>`), {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+async function getRequestHandlerOptions(route, request, env) {
+    const [htmlTemplate, routeManifest, loadableStats] = await Promise.all([
+        readAssetText(route.entryPath, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.routeManifest, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.loadableStats, request, env)
+    ]);
+    return createRequestHandlerOptions({
+        route,
+        htmlTemplate: htmlTemplate || '',
+        routeManifest,
+        loadableStats
+    });
+}
+async function loadWorkerModule(workerPath) {
+    const loader = WORKER_MODULE_LOADERS[workerPath];
+    if (!loader) return;
+    if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
+    return workerModulePromises.get(workerPath);
+}
+function getRuntimeModule(workerModule) {
+    const defaultExport = workerModule.default;
+    const nestedDefaultExport = defaultExport && 'object' == typeof defaultExport ? defaultExport.default : void 0;
+    return defaultExport && 'object' == typeof defaultExport ? {
+        ...workerModule,
+        ...defaultExport,
+        ...nestedDefaultExport && 'object' == typeof nestedDefaultExport ? nestedDefaultExport : {}
+    } : workerModule;
+}
+function getFetchHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    return 'function' == typeof runtime.fetch && runtime.fetch.bind(runtime) || 'function' == typeof defaultExport && defaultExport.fetch?.bind?.(defaultExport);
+}
+async function getRequestHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    return await workerModule.requestHandler || await runtime.requestHandler || ('function' == typeof defaultExport ? defaultExport : void 0);
+}
+async function dispatchRouteWorker(route, request, env, ctx) {
+    const workerPath = route.worker;
+    if (!workerPath) return new Response('Worker bundle not configured for SSR route', {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+    const workerModule = await loadWorkerModule(workerPath);
+    if (!workerModule) return new Response(`Worker bundle not found: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+    const fetchHandler = getFetchHandler(workerModule);
+    if (fetchHandler) return fetchHandler(request, env, ctx);
+    const requestHandler = await getRequestHandler(workerModule);
+    if ('function' == typeof requestHandler) {
+        const requestHandlerOptions = await getRequestHandlerOptions(route, request, env);
+        return withRouteCssLinks(await requestHandler(request, requestHandlerOptions), route, requestHandlerOptions.resource.routeManifest, request, env);
+    }
+    return new Response(`Worker bundle has no fetch or requestHandler export: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+}
+function matchesPrefix(pathname, prefix) {
+    if (!prefix || '/' === prefix) return true;
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createRequestForMountedPrefix(request, prefix) {
+    if (!prefix || '/' === prefix) return request;
+    const url = new URL(request.url);
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    if (!matchesPrefix(url.pathname, normalized)) return request;
+    const nextPath = url.pathname.slice(normalized.length) || '/';
+    url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
+    return new Request(url, request);
+}
+function createEffectContext(originalRequest, mountedRequest, env) {
+    const url = new URL(originalRequest.url);
+    return {
+        request: mountedRequest,
+        env: env || {},
+        path: url.pathname,
+        method: originalRequest.method,
+        operationContext: {
+            request: mountedRequest,
+            env: env || {},
+            path: url.pathname,
+            method: originalRequest.method
+        }
+    };
+}
+async function dispatchBffRequest(request, env) {
+    const bff = MODERN_WORKER_MANIFEST.bff;
+    if (!bff?.worker || !matchesPrefix(new URL(request.url).pathname, bff.prefix)) return null;
+    const workerModule = await loadWorkerModule(bff.worker);
+    if (!workerModule) return new Response(`BFF worker bundle not found: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
+    const effectContext = createEffectContext(request, mountedRequest, env);
+    const defaultExport = workerModule.default;
+    const runtime = getRuntimeModule(workerModule);
+    const directHandler = 'function' == typeof runtime.handler && runtime.handler || 'function' == typeof defaultExport && defaultExport;
+    const createdHandler = 'function' == typeof runtime.createHandler ? runtime.createHandler().handler : void 0;
+    const handler = directHandler || createdHandler;
+    if ('function' != typeof handler) return new Response(`BFF worker bundle has no handler export: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    return handler.length > 1 ? handler(mountedRequest, effectContext) : handler(mountedRequest);
+}
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = createCorsPreflightResponse(request);
+        if (corsPreflightResponse) return corsPreflightResponse;
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return assetResponse;
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return withCorsHeaders(bffResponse);
+        const route = findRoute(request);
+        const { pathname } = new URL(request.url);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) return withCorsHeaders(new Response('Not found', {
+            status: 404
+        }));
+        if (route?.worker) return withCorsHeaders(await dispatchRouteWorker(route, request, env, ctx));
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return htmlResponse;
+        return withCorsHeaders(new Response('Not found', {
+            status: 404
+        }));
+    }
+};

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-worker-fs-promises.mjs

@@ -0,0 +1,7 @@
+const unavailable = (method)=>async ()=>{
+        throw new Error(`node:fs/promises.${method} is unavailable in Cloudflare Worker SSR`);
+    };
+export const readFile = unavailable('readFile');
+export default {
+    readFile
+};

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-worker-loadable-server.mjs

@@ -0,0 +1,185 @@
+import loadableComponent from '@loadable/component';
+import React from 'react';
+const internals = loadableComponent?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED || {};
+const LoadableContext = internals.Context || React.createContext(null);
+const getRequiredChunkKey = internals.getRequiredChunkKey || ((namespace)=>`${namespace}__LOADABLE_REQUIRED_CHUNKS__`);
+const scriptExtensions = new Set([
+    '.js',
+    '.mjs'
+]);
+const styleExtensions = new Set([
+    '.css'
+]);
+function uniqByUrl(assets) {
+    const seen = new Set();
+    return assets.filter((asset)=>{
+        if (seen.has(asset.url)) return false;
+        seen.add(asset.url);
+        return true;
+    });
+}
+function extname(filePath) {
+    const basename = String(filePath).split('/').pop() || '';
+    const index = basename.lastIndexOf('.');
+    return index > 0 ? basename.slice(index) : '';
+}
+function joinUrl(publicPath, filename) {
+    const base = publicPath || '/';
+    return `${base.replace(/\/+$/u, '')}/${String(filename).replace(/^\/+/u, '')}`;
+}
+function extraPropsToString(extraProps = {}) {
+    return Object.entries(extraProps).filter(([, value])=>void 0 !== value && false !== value).map(([key, value])=>true === value ? ` ${key}` : ` ${key}="${value}"`).join('');
+}
+function assetScriptType(filename) {
+    const extension = extname(filename);
+    if (scriptExtensions.has(extension)) return "script";
+    if (styleExtensions.has(extension)) return 'style';
+}
+function getAssetName(asset) {
+    return 'object' == typeof asset && asset?.name ? asset.name : asset;
+}
+function getAssetIntegrity(asset) {
+    return 'object' == typeof asset && asset?.integrity ? asset.integrity : null;
+}
+function getChunkGroupAssets(chunkGroup) {
+    const assets = chunkGroup?.assets;
+    if (Array.isArray(assets)) return assets;
+    if (assets && 'object' == typeof assets) return [
+        ...assets.js || [],
+        ...assets.css || []
+    ];
+    return [];
+}
+function getChunkGroupChildAssets(chunkGroup, type) {
+    const childAssets = chunkGroup?.childAssets?.[type];
+    return Array.isArray(childAssets) ? childAssets : [];
+}
+function chunkIncludesJs(chunkInfo) {
+    return (chunkInfo?.files || []).some((file)=>scriptExtensions.has(extname(file)));
+}
+export function ChunkExtractorManager({ extractor, children }) {
+    return React.createElement(LoadableContext.Provider, {
+        value: extractor
+    }, children);
+}
+export class ChunkExtractor {
+    constructor({ stats, entrypoints = [
+        'main'
+    ], namespace = '', outputPath = '/', publicPath } = {}){
+        this.namespace = namespace;
+        this.stats = stats || {};
+        this.publicPath = publicPath || this.stats.publicPath || '/';
+        this.outputPath = outputPath || this.stats.outputPath || '/';
+        this.entrypoints = Array.isArray(entrypoints) ? entrypoints : [
+            entrypoints
+        ];
+        this.chunks = [];
+    }
+    addChunk(chunk) {
+        if (!this.chunks.includes(chunk)) this.chunks.push(chunk);
+    }
+    collectChunks(app) {
+        return React.createElement(ChunkExtractorManager, {
+            extractor: this
+        }, app);
+    }
+    getChunkGroup(chunk) {
+        return this.stats.namedChunkGroups?.[chunk] || {
+            assets: [],
+            childAssets: {},
+            chunks: []
+        };
+    }
+    getChunkInfo(chunkId) {
+        return (this.stats.chunks || []).find((chunk)=>chunk.id === chunkId);
+    }
+    resolvePublicUrl(filename) {
+        return joinUrl(this.publicPath, filename);
+    }
+    createChunkAsset({ filename, chunk, type, linkType }) {
+        const resolvedFilename = getAssetName(filename);
+        const scriptType = assetScriptType(resolvedFilename);
+        if (!scriptType) return;
+        return {
+            filename: resolvedFilename,
+            integrity: getAssetIntegrity(filename),
+            scriptType,
+            chunk,
+            url: this.resolvePublicUrl(resolvedFilename),
+            path: String(resolvedFilename).replace(/^\/+/u, ''),
+            type,
+            linkType
+        };
+    }
+    getChunkAssets(chunks) {
+        const one = (chunk)=>getChunkGroupAssets(this.getChunkGroup(chunk)).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'mainAsset',
+                    linkType: 'preload'
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkChildAssets(chunks, type) {
+        const one = (chunk)=>getChunkGroupChildAssets(this.getChunkGroup(chunk), type).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'childAsset',
+                    linkType: type
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkDependencies(chunks) {
+        const one = (chunk)=>(this.getChunkGroup(chunk).chunks || []).filter((chunkId)=>chunkIncludesJs(this.getChunkInfo(chunkId)));
+        return Array.isArray(chunks) ? [
+            ...new Set(chunks.flatMap(one))
+        ] : one(chunks);
+    }
+    getRequiredChunksScriptContent() {
+        return JSON.stringify(this.getChunkDependencies(this.chunks));
+    }
+    getRequiredChunksNamesScriptContent() {
+        return JSON.stringify({
+            namedChunks: this.chunks
+        });
+    }
+    getRequiredChunksScriptTag(extraProps = {}) {
+        const id = getRequiredChunkKey(this.namespace);
+        const props = `type="application/json"${extraPropsToString(extraProps)}`;
+        return [
+            `<script id="${id}" ${props}>${this.getRequiredChunksScriptContent()}</script>`,
+            `<script id="${id}_ext" ${props}>${this.getRequiredChunksNamesScriptContent()}</script>`
+        ].join('');
+    }
+    getMainAssets(scriptType) {
+        const assets = this.getChunkAssets([
+            ...this.entrypoints,
+            ...this.chunks
+        ]);
+        return scriptType ? assets.filter((asset)=>asset.scriptType === scriptType) : assets;
+    }
+    getScriptTags(extraProps = {}) {
+        const scripts = this.getMainAssets("script").map((asset)=>`<script async data-chunk="${asset.chunk}" src="${asset.url}"${extraPropsToString(extraProps)}></script>`);
+        return [
+            this.getRequiredChunksScriptTag(extraProps),
+            ...scripts
+        ].join('');
+    }
+    getStyleTags(extraProps = {}) {
+        return this.getMainAssets('style').map((asset)=>`<link data-chunk="${asset.chunk}" rel="stylesheet" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+    getLinkTags(extraProps = {}) {
+        const assets = [
+            ...this.getMainAssets(),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'preload'),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'prefetch')
+        ];
+        return uniqByUrl(assets).map((asset)=>`<link data-chunk="${asset.chunk}" rel="${asset.linkType}" as="${asset.scriptType}" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+}

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-worker-path.mjs

@@ -0,0 +1,59 @@
+const trimSlashes = (value)=>String(value).replace(/^\/+|\/+$/gu, '');
+const normalizeSeparators = (value)=>String(value).replace(/\\+/gu, '/');
+export const sep = '/';
+export const delimiter = ':';
+export function isAbsolute(filePath) {
+    return normalizeSeparators(filePath).startsWith('/');
+}
+export function normalize(filePath) {
+    const normalized = normalizeSeparators(filePath);
+    const absolute = isAbsolute(normalized);
+    const parts = [];
+    for (const part of normalized.split('/'))if (part && '.' !== part) {
+        if ('..' === part) {
+            if (parts.length > 0 && '..' !== parts[parts.length - 1]) parts.pop();
+            else if (!absolute) parts.push(part);
+            continue;
+        }
+        parts.push(part);
+    }
+    const joined = parts.join('/');
+    if (absolute) return joined ? `/${joined}` : '/';
+    return joined || '.';
+}
+export function join(...segments) {
+    const joined = segments.map(normalizeSeparators).filter(Boolean).map((segment, index)=>0 === index ? segment : trimSlashes(segment)).filter(Boolean).join('/');
+    return joined ? normalize(joined) : '.';
+}
+export function resolve(...segments) {
+    const joined = join(...segments);
+    return joined.startsWith('/') ? joined : `/${joined}`;
+}
+export function dirname(filePath) {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const index = normalized.lastIndexOf('/');
+    if (index <= 0) return '/';
+    return normalized.slice(0, index);
+}
+export function basename(filePath, suffix = '') {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const base = normalized.slice(normalized.lastIndexOf('/') + 1);
+    return suffix && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+export function extname(filePath) {
+    const base = basename(filePath);
+    const index = base.lastIndexOf('.');
+    if (index <= 0) return '';
+    return base.slice(index);
+}
+export default {
+    basename,
+    delimiter,
+    dirname,
+    extname,
+    isAbsolute,
+    join,
+    normalize,
+    resolve,
+    sep
+};