@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.2

package/dist/esm-node/templates/cloudflare-worker-loadable-server.mjs

@@ -0,0 +1,281 @@
+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 isAutomaticPublicPath(publicPath) {
+  return publicPath === 'auto' || publicPath === 'auto/';
+}
+
+function joinUrl(publicPath, filename) {
+  const base =
+    !publicPath || isAutomaticPublicPath(publicPath) ? '/' : publicPath;
+
+  return `${base.replace(/\/+$/u, '')}/${String(filename).replace(/^\/+/u, '')}`;
+}
+
+function extraPropsToString(extraProps = {}) {
+  return Object.entries(extraProps)
+    .filter(([, value]) => value !== undefined && value !== false)
+    .map(([key, value]) => (value === true ? ` ${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 typeof asset === 'object' && asset?.name ? asset.name : asset;
+}
+
+function getAssetIntegrity(asset) {
+  return typeof asset === 'object' && asset?.integrity ? asset.integrity : null;
+}
+
+function getChunkGroupAssets(chunkGroup) {
+  const assets = chunkGroup?.assets;
+
+  if (Array.isArray(assets)) {
+    return assets;
+  }
+
+  if (assets && typeof assets === 'object') {
+    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 || {};
+    const configuredPublicPath = publicPath || this.stats.publicPath;
+    this.publicPath =
+      !configuredPublicPath || isAutomaticPublicPath(configuredPublicPath)
+        ? '/'
+        : configuredPublicPath;
+    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 undefined;
+    }
+
+    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-node/templates/cloudflare-worker-mf-ssr-runtime-plugin.mjs

@@ -0,0 +1,14 @@
+/**
+ * Workerd cannot initialize Module Federation's Node-oriented SSR data-fetch
+ * runtime. Cloudflare workers do not load native MF remotes, so retain the
+ * runtime-plugin contract without installing its server data-fetch hooks.
+ */
+export const injectDataFetchFunctionPlugin = () => ({
+  name: '@module-federation/inject-data-fetch-function-plugin',
+  setup() {},
+});
+
+export const mfSSRDevPlugin = () => ({
+  name: '@module-federation/modern-js-v3',
+  setup() {},
+});

package/dist/esm-node/templates/cloudflare-worker-path.mjs

@@ -0,0 +1,98 @@
+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 === '.') {
+      continue;
+    }
+
+    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) => (index === 0 ? 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,
+};

package/dist/types/cloudflare/artifacts.d.ts

@@ -0,0 +1,15 @@
+import type { CloudflareModernConfig } from './types';
+export declare const getCloudflareArtifacts: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+export declare const getCloudflarePublicAssets: (modernConfig: CloudflareModernConfig) => {
+    from: string;
+    to: string;
+    index: number;
+}[];
+export declare const copyCloudflareArtifacts: (appDirectory: string, outputDirectory: string, artifacts: ReturnType<typeof getCloudflareArtifacts>) => Promise<void>;
+export declare const copyCloudflarePublicAssets: (appDirectory: string, publicDirectory: string, publicAssets: ReturnType<typeof getCloudflarePublicAssets>) => Promise<void>;
+export declare const copyCloudflareD1Migrations: (appDirectory: string, outputDirectory: string, modernConfig: CloudflareModernConfig) => Promise<void>;
+export declare const readRouteSpec: (outputDirectory: string) => Promise<any>;

package/dist/types/cloudflare/constants.d.ts

@@ -0,0 +1,24 @@
+import { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT } from '../cloudflare-output-contract';
+export { CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT };
+export declare const WORKER_ENTRY = "server/index.mjs";
+export declare const WORKER_MANIFEST = "server/modern-worker-manifest.json";
+export declare const WRANGLER_CONFIG_FILE = "wrangler.json";
+export declare const OUTPUT_PACKAGE_FILE = "package.json";
+export declare const ASSETS_BINDING = "ASSETS";
+export declare const ROUTE_SPEC_FILE = "route.json";
+export declare const ROUTE_SPEC_OUTPUT = "server/route.json";
+export declare const LOADABLE_STATS_FILE = "loadable-stats.json";
+export declare const ROUTE_MANIFEST_FILE = "routes-manifest.json";
+export declare const PUBLIC_ASSETS_DIRECTORY = "public";
+export declare const WORKER_BUNDLE_DIRECTORY = "worker";
+export declare const SERVER_BUNDLE_DIRECTORY = "bundles";
+export declare const SERVER_OUTPUT_DIRECTORY = "server";
+export declare const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES: readonly ['api', 'shared'];
+export declare const BFF_EFFECT_WORKER_ENTRY = "worker/__modern_bff_effect.js";
+export declare const BFF_EFFECT_WORKER_DISPATCHER_EXPORT = "__modern_create_effect_bff_dispatcher";
+export declare const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = "Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.";
+export declare const DEFAULT_COMPATIBILITY_DATE = "2026-06-02";
+export declare const COMPATIBILITY_DATE_PATTERN: RegExp;
+export declare const REQUIRED_COMPATIBILITY_FLAGS: readonly ["nodejs_compat", "global_fetch_strictly_public"];
+export declare const RESERVED_ARTIFACT_DESTINATION_FILES: Set<string>;
+export declare const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES: Set<string>;

package/dist/types/cloudflare/delivery-unit.d.ts

@@ -0,0 +1,23 @@
+import { type DeliveryUnitIdentity } from '@modern-js/utils/universal';
+export type DeliveryUnitStamp = DeliveryUnitIdentity & {
+    surfaces: {
+        ui?: DeliveryUnitIdentity & {
+            surface: 'ui';
+        };
+        api?: DeliveryUnitIdentity & {
+            surface: 'api';
+        };
+    };
+};
+/**
+ * Resolve the delivery-unit record declared for this app by the workspace
+ * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * of truth the Cloudflare worker snapshot is verified against.
+ */
+export declare const resolveTopologyDeliveryUnit: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;
+/**
+ * Resolve the delivery-unit identity actually bundled into the worker by
+ * parsing the generated `shared/ultramodern-build.ts` module. This is the
+ * worker snapshot / declared surface source that gets stamped into the manifest.
+ */
+export declare const resolveWorkerDeliveryUnitStamp: (appDirectory: string) => Promise<DeliveryUnitStamp | undefined>;

package/dist/types/cloudflare/i18n-worker.d.ts

@@ -0,0 +1,22 @@
+import type { CloudflareAppContext } from './types';
+type WorkerI18nDetection = {
+    order: string[];
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupHeader: string;
+};
+type WorkerI18nEntry = {
+    i18nextDetector: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    detection: WorkerI18nDetection;
+    ignoreRedirectRoutes: string[];
+    staticRoutePrefixes: string[];
+    localisedUrls?: Record<string, Record<string, string>>;
+};
+export declare const createI18nWorkerManifest: (routeSpec: {
+    routes: Array<Record<string, unknown>>;
+}, appContext: CloudflareAppContext) => {
+    entries: Record<string, WorkerI18nEntry>;
+} | undefined;
+export {};

package/dist/types/cloudflare/index.d.ts

@@ -0,0 +1,2 @@
+import type { CreateCloudflarePreset } from './types';
+export declare const createCloudflarePreset: CreateCloudflarePreset;

package/dist/types/cloudflare/security-policies.d.ts

@@ -0,0 +1,52 @@
+import type { CloudflareModernConfig } from './types';
+export declare const createCloudflareWorkerSecurityPolicy: (modernConfig: CloudflareModernConfig) => {
+    enabled: boolean;
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: string | undefined;
+    headers?: undefined;
+    contentSecurityPolicy?: undefined;
+    noindex?: undefined;
+} | {
+    enabled: boolean;
+    headers: {
+        referrerPolicy: string | false;
+        contentTypeOptions: "nosniff" | false;
+        permissionsPolicy: string | false;
+    };
+    contentSecurityPolicy: {
+        mode: "off";
+        directives: {};
+        reason: string | undefined;
+    } | {
+        mode: "enforce" | "report-only";
+        directives: {
+            [k: string]: string[];
+        };
+        reason: string | undefined;
+    };
+    noindex: {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: never[];
+        reason?: undefined;
+    } | {
+        workersDev: boolean;
+        localhost: boolean;
+        previewHostnames: string[];
+        reason: string | undefined;
+    };
+    cors: {
+        assets: boolean;
+        allowedOrigins: string[];
+        allowedMethods: string[];
+        allowedHeaders: string[];
+        reason: string | undefined;
+    };
+    reason: string | undefined;
+};

package/dist/types/cloudflare/types.d.ts

@@ -0,0 +1,28 @@
+import type { BffUserConfig } from '@modern-js/server-core';
+import type { ServerPlugin } from '@modern-js/types';
+import type { CloudflareDeployConfig } from '../config';
+export interface CloudflareAppContext {
+    apiOnly: boolean;
+    appDirectory: string;
+    distDirectory: string;
+    serverPlugins: ServerPlugin[];
+}
+export interface CloudflareModernConfig {
+    bff?: BffUserConfig;
+    deploy?: CloudflareDeployConfig;
+}
+export interface CloudflarePresetApi {
+    isPluginExists(name: string): boolean;
+}
+export type CloudflareDeployPreset = {
+    prepare?: () => Promise<void>;
+    writeOutput?: () => Promise<void>;
+    genEntry?: () => Promise<void>;
+    end?: () => Promise<void>;
+};
+export type CreateCloudflarePreset = (params: {
+    appContext: CloudflareAppContext;
+    modernConfig: CloudflareModernConfig;
+    api: CloudflarePresetApi;
+    needModernServer?: boolean;
+}) => CloudflareDeployPreset;

package/dist/types/cloudflare/utils.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from '../config';
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const normalizeRelativePath: (value: unknown, label: string, scope?: string, options?: {
+    allowRoot?: boolean;
+}) => string;
+export declare const isJsonRecord: (value: unknown) => value is Record<string, JsonValue>;