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

package/dist/cjs/cloudflare-builder.js

@@ -0,0 +1,394 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+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__, {
+    applyCloudflareBuilderEnvironments: ()=>applyCloudflareBuilderEnvironments,
+    applyCloudflareWorkerMfRuntimeBoundary: ()=>applyCloudflareWorkerMfRuntimeBoundary,
+    applyCloudflareWorkerRspackConfig: ()=>applyCloudflareWorkerRspackConfig,
+    createCloudflareBuilderPlugin: ()=>createCloudflareBuilderPlugin,
+    getCloudflareBuilderEnvironments: ()=>getCloudflareBuilderEnvironments,
+    getCloudflareWorkerRspackConfig: ()=>getCloudflareWorkerRspackConfig
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const builder_namespaceObject = require("@modern-js/builder");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_std_env_namespaceObject = require("std-env");
+const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
+const external_read_template_js_namespaceObject = require("./read-template.js");
+const moduleRequire = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
+const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
+const MF_SSR_DATA_FETCH_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-inject-data-fetch-function-plugin';
+const MF_SSR_DEV_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-dev-plugin';
+const JS_OR_TS_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+]);
+const findExistingFile = (candidates)=>candidates.find((candidate)=>external_node_fs_default().existsSync(candidate));
+const resolveJsOrTsEntry = (entryWithoutOrWithExtension)=>{
+    if (JS_OR_TS_EXTENSIONS.has(external_node_path_default().extname(entryWithoutOrWithExtension))) return external_node_fs_default().existsSync(entryWithoutOrWithExtension) ? entryWithoutOrWithExtension : void 0;
+    return findExistingFile([
+        ...JS_OR_TS_EXTENSIONS
+    ].map((extension)=>`${entryWithoutOrWithExtension}${extension}`));
+};
+const resolvePackageEntry = (packageName, paths)=>{
+    try {
+        return external_node_fs_default().realpathSync(moduleRequire.resolve(packageName, {
+            paths
+        }));
+    } catch  {
+        return;
+    }
+};
+const findPackageRoot = (entryFile, packageName)=>{
+    let directory = external_node_path_default().dirname(entryFile);
+    while(directory !== external_node_path_default().dirname(directory)){
+        const packageJsonPath = external_node_path_default().join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf-8'));
+            if ('object' == typeof packageJson && null !== packageJson && 'name' in packageJson && packageJson.name === packageName) return directory;
+        } catch  {}
+        directory = external_node_path_default().dirname(directory);
+    }
+};
+const resolvePackageFile = (packageName, filePath, paths)=>{
+    try {
+        return external_node_fs_default().realpathSync(moduleRequire.resolve(`${packageName}/${filePath}`, {
+            paths
+        }));
+    } catch  {
+        try {
+            const packageJsonPath = moduleRequire.resolve(`${packageName}/package.json`, {
+                paths
+            });
+            const packageFile = external_node_path_default().join(external_node_path_default().dirname(packageJsonPath), filePath);
+            if (external_node_fs_default().existsSync(packageFile)) return external_node_fs_default().realpathSync(packageFile);
+        } catch  {}
+        const packageEntry = resolvePackageEntry(packageName, paths);
+        const packageRoot = packageEntry ? findPackageRoot(packageEntry, packageName) : void 0;
+        const packageFile = packageRoot ? external_node_path_default().join(packageRoot, filePath) : void 0;
+        return packageFile && external_node_fs_default().existsSync(packageFile) ? external_node_fs_default().realpathSync(packageFile) : void 0;
+    }
+};
+const setAliasIfPresent = (alias, name, value)=>{
+    if (value) alias.set(name, value);
+};
+const getCloudflareWorkerNodeExternals = ()=>Object.fromEntries(external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
+        const nodeBuiltin = `node:${builtin}`;
+        return [
+            [
+                builtin,
+                `module-import ${nodeBuiltin}`
+            ],
+            [
+                nodeBuiltin,
+                `module-import ${nodeBuiltin}`
+            ]
+        ];
+    }));
+const normalizeWorkerOutputName = (name)=>external_node_path_default().posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
+const reserveWorkerChunkName = (baseName, reservedOutputNames)=>{
+    let name = baseName;
+    while(reservedOutputNames.has(normalizeWorkerOutputName(name)))name = `${name}_`;
+    return name;
+};
+function getCloudflareWorkerRspackConfig(workerEntryNames) {
+    const entryNames = [
+        ...workerEntryNames
+    ];
+    for (const entryName of entryNames){
+        const slashName = entryName.replace(/\\/gu, '/');
+        const normalizedName = external_node_path_default().posix.normalize(slashName);
+        if (entryName !== slashName || normalizedName !== slashName || '.' === normalizedName || normalizedName.startsWith('../') || external_node_path_default().posix.isAbsolute(normalizedName) || external_node_path_default().win32.isAbsolute(slashName) || /^[A-Za-z]:/u.test(slashName)) throw new Error(`Cloudflare worker entry name "${entryName}" must be a canonical relative output path without dot segments or backslashes.`);
+    }
+    const reservedNames = new Set(entryNames.map(normalizeWorkerOutputName));
+    const runtimeName = reserveWorkerChunkName('__modern_worker_runtime', reservedNames);
+    reservedNames.add(normalizeWorkerOutputName(runtimeName));
+    const sharedName = reserveWorkerChunkName('__modern_worker_shared', reservedNames);
+    return {
+        externals: getCloudflareWorkerNodeExternals(),
+        externalsType: 'module-import',
+        module: {
+            parser: {
+                javascript: {
+                    dynamicImportMode: 'eager'
+                }
+            }
+        },
+        optimization: {
+            runtimeChunk: {
+                name: runtimeName
+            },
+            splitChunks: {
+                chunks: 'all',
+                minSize: 0,
+                name: sharedName
+            }
+        }
+    };
+}
+function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
+    const config = getCloudflareWorkerRspackConfig(workerEntryNames);
+    chain.externals(config.externals);
+    chain.externalsType(config.externalsType);
+    chain.module.parser.merge(config.module.parser);
+    chain.optimization.runtimeChunk(config.optimization.runtimeChunk);
+    chain.optimization.splitChunks(config.optimization.splitChunks);
+}
+function applyCloudflareWorkerMfRuntimeBoundary(chain) {
+    const runtimePlugin = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-mf-ssr-runtime-plugin.mjs');
+    chain.plugins.delete('plugin-module-federation');
+    chain.resolve.alias.set(`${MF_SSR_DATA_FETCH_RUNTIME_PLUGIN}$`, runtimePlugin);
+    chain.resolve.alias.set(`${MF_SSR_DEV_RUNTIME_PLUGIN}$`, runtimePlugin);
+}
+const getEffectBffEntry = (normalizedConfig, appContext)=>{
+    if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
+    const configuredEntry = normalizedConfig.bff.effect?.entry;
+    if (configuredEntry) {
+        const entryWithoutOrWithExtension = external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appContext.appDirectory, configuredEntry);
+        return resolveJsOrTsEntry(entryWithoutOrWithExtension);
+    }
+    return resolveJsOrTsEntry(external_node_path_default().resolve(appContext.apiDirectory, 'index'));
+};
+const CLOUDFLARE_DEPLOY_PROVIDERS = new Set([
+    'cloudflare',
+    'cloudflare_pages',
+    'cloudflare_workers'
+]);
+const resolveStdEnvDeployProvider = ()=>external_std_env_namespaceObject.provider;
+const isCloudflareWorkerDeploy = (normalizedConfig, resolveDeployProvider)=>{
+    const explicitTarget = normalizedConfig.deploy?.target || process.env.MODERNJS_DEPLOY;
+    if (explicitTarget) return 'cloudflare' === explicitTarget;
+    const detectedProvider = resolveDeployProvider();
+    return detectedProvider ? CLOUDFLARE_DEPLOY_PROVIDERS.has(detectedProvider) : false;
+};
+const rewriteWorkerEntryPath = (entry)=>entry.replace('index.jsx', 'index.server.jsx').replace('bootstrap.server.jsx', 'index.server.jsx').replace('bootstrap.jsx', 'index.server.jsx');
+const rewriteWorkerEntryDescription = (description)=>{
+    const entryImport = description.import;
+    if ('string' == typeof entryImport) return {
+        ...description,
+        import: rewriteWorkerEntryPath(entryImport)
+    };
+    if (Array.isArray(entryImport)) return {
+        ...description,
+        import: entryImport.map(rewriteWorkerEntryPath)
+    };
+    return description;
+};
+const rewriteWorkerEntries = (entries)=>Object.fromEntries(Object.entries(entries).map(([name, value])=>{
+        if ('string' == typeof value) return [
+            name,
+            rewriteWorkerEntryPath(value)
+        ];
+        if (Array.isArray(value)) return [
+            name,
+            value.map(rewriteWorkerEntryPath)
+        ];
+        return [
+            name,
+            rewriteWorkerEntryDescription(value)
+        ];
+    }));
+const prependBundlerChain = (environment, handler)=>{
+    const bundlerChain = environment.tools?.bundlerChain;
+    return {
+        ...environment,
+        tools: {
+            ...environment.tools,
+            htmlPlugin: false,
+            bundlerChain: bundlerChain ? Array.isArray(bundlerChain) ? [
+                handler,
+                ...bundlerChain
+            ] : [
+                handler,
+                bundlerChain
+            ] : handler
+        }
+    };
+};
+const getWorkerEntries = (environment, normalizedConfig, appContext)=>{
+    const configuredEntries = environment.source?.entry;
+    if (!configuredEntries) return;
+    const entries = rewriteWorkerEntries(configuredEntries);
+    const effectApiEntry = getEffectBffEntry(normalizedConfig, appContext);
+    return effectApiEntry ? {
+        ...entries,
+        [BFF_EFFECT_WORKER_ENTRY_NAME]: [
+            `${effectApiEntry}?${BFF_EFFECT_WORKER_RUNTIME_QUERY}`
+        ]
+    } : entries;
+};
+const createCloudflareBundlerChain = (appContext, workerEntryNames)=>{
+    const resolvePaths = [
+        appContext.appDirectory,
+        process.cwd()
+    ];
+    const tanstackRouterSsrServerFile = resolvePackageFile('@tanstack/router-core', 'dist/esm/ssr/ssr-server.js', resolvePaths);
+    const runtimeRscWorkerFile = resolvePackageFile('@modern-js/runtime', 'dist/esm/rsc/server.worker.mjs', resolvePaths);
+    const renderRscWorkerFile = resolvePackageFile('@modern-js/render', 'dist/esm/rscWorker.mjs', resolvePaths);
+    const reactFile = resolvePackageFile('react', 'index.js', resolvePaths);
+    const reactJsxRuntimeFile = resolvePackageFile('react', 'jsx-runtime.js', resolvePaths);
+    const reactJsxDevRuntimeFile = resolvePackageFile('react', 'jsx-dev-runtime.js', resolvePaths);
+    const reactDomFile = resolvePackageFile('react-dom', 'index.js', resolvePaths);
+    const reactDomServerEdgeFile = resolvePackageFile('react-dom', 'server.edge.js', resolvePaths);
+    const loadableComponentFile = resolvePackageFile('@loadable/component', 'dist/esm/loadable.esm.mjs', [
+        ...resolvePaths,
+        (0, external_read_template_js_namespaceObject.getTemplatePath)('')
+    ]);
+    const loadableServerWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-loadable-server.mjs');
+    const fsPromisesWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-fs-promises.mjs');
+    const pathWorkerFile = (0, external_read_template_js_namespaceObject.getTemplatePath)('cloudflare-worker-path.mjs');
+    const entryNames = [
+        ...workerEntryNames
+    ];
+    return (chain)=>{
+        applyCloudflareWorkerRspackConfig(chain, entryNames);
+        chain.output.module(true).library({
+            type: 'module'
+        }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+        for (const condition of [
+            'workerd',
+            'worker',
+            'webpack',
+            (0, utils_namespaceObject.isProd)() ? 'production' : 'development',
+            'import',
+            'require',
+            'module'
+        ])chain.resolve.conditionNames.add(condition);
+        applyCloudflareWorkerMfRuntimeBoundary(chain);
+        if (tanstackRouterSsrServerFile) {
+            chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
+            chain.resolve.alias.set('@tanstack/router-core/ssr/server', tanstackRouterSsrServerFile);
+        }
+        if (runtimeRscWorkerFile) {
+            chain.resolve.alias.set('@modern-js/runtime/rsc/server$', runtimeRscWorkerFile);
+            chain.resolve.alias.set('@modern-js/runtime/rsc/server', runtimeRscWorkerFile);
+        }
+        if (renderRscWorkerFile) {
+            chain.resolve.alias.set('@modern-js/render/rsc$', renderRscWorkerFile);
+            chain.resolve.alias.set('@modern-js/render/rsc', renderRscWorkerFile);
+            chain.resolve.alias.set('@modern-js/render/rsc-worker$', renderRscWorkerFile);
+        }
+        setAliasIfPresent(chain.resolve.alias, 'react$', reactFile);
+        setAliasIfPresent(chain.resolve.alias, 'react/jsx-runtime$', reactJsxRuntimeFile);
+        setAliasIfPresent(chain.resolve.alias, 'react/jsx-dev-runtime$', reactJsxDevRuntimeFile);
+        setAliasIfPresent(chain.resolve.alias, 'react-dom$', reactDomFile);
+        setAliasIfPresent(chain.resolve.alias, 'react-dom/server.edge$', reactDomServerEdgeFile);
+        setAliasIfPresent(chain.resolve.alias, '@loadable/component$', loadableComponentFile);
+        setAliasIfPresent(chain.resolve.alias, '@loadable/server$', loadableServerWorkerFile);
+        setAliasIfPresent(chain.resolve.alias, 'fs/promises$', fsPromisesWorkerFile);
+        setAliasIfPresent(chain.resolve.alias, 'node:fs/promises$', fsPromisesWorkerFile);
+        setAliasIfPresent(chain.resolve.alias, 'path$', pathWorkerFile);
+        setAliasIfPresent(chain.resolve.alias, 'node:path$', pathWorkerFile);
+        chain.resolve.alias.set('react-server-dom-rspack/server.node$', 'react-server-dom-rspack/server.edge');
+        chain.resolve.alias.set('react-server-dom-rspack/server.node', 'react-server-dom-rspack/server.edge');
+        chain.resolve.alias.set('react-server-dom-rspack/client.node$', 'react-server-dom-rspack/client.edge');
+        chain.resolve.alias.set('react-server-dom-rspack/client.node', 'react-server-dom-rspack/client.edge');
+        chain.resolve.fallback.set('fs', false);
+        chain.resolve.fallback.set('node:fs', false);
+    };
+};
+function getCloudflareBuilderEnvironments({ appContext, environments, normalizedConfig, resolveDeployProvider = resolveStdEnvDeployProvider }) {
+    if (!isCloudflareWorkerDeploy(normalizedConfig, resolveDeployProvider)) return environments;
+    const workerEnvironment = environments[builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME];
+    if (!workerEnvironment) return environments;
+    const workerEntries = getWorkerEntries(workerEnvironment, normalizedConfig, appContext);
+    if (!workerEntries) return environments;
+    const cloudflareWorkerEnvironment = prependBundlerChain({
+        ...workerEnvironment,
+        output: {
+            ...workerEnvironment.output,
+            module: true,
+            target: 'web'
+        },
+        source: {
+            ...workerEnvironment.source,
+            entry: workerEntries
+        }
+    }, createCloudflareBundlerChain(appContext, Object.keys(workerEntries)));
+    return {
+        ...environments,
+        [builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]: cloudflareWorkerEnvironment
+    };
+}
+function applyCloudflareBuilderEnvironments(options) {
+    return {
+        environments: getCloudflareBuilderEnvironments(options)
+    };
+}
+const createCloudflareBuilderPlugin = (resolveDeployProvider = resolveStdEnvDeployProvider)=>({
+        name: '@modern-js/cloudflare-builder',
+        setup (api) {
+            api.modifyBuilderEnvironments(({ environments })=>applyCloudflareBuilderEnvironments({
+                    appContext: api.getAppContext(),
+                    environments,
+                    normalizedConfig: api.getNormalizedConfig(),
+                    resolveDeployProvider
+                }));
+        }
+    });
+exports.applyCloudflareBuilderEnvironments = __webpack_exports__.applyCloudflareBuilderEnvironments;
+exports.applyCloudflareWorkerMfRuntimeBoundary = __webpack_exports__.applyCloudflareWorkerMfRuntimeBoundary;
+exports.applyCloudflareWorkerRspackConfig = __webpack_exports__.applyCloudflareWorkerRspackConfig;
+exports.createCloudflareBuilderPlugin = __webpack_exports__.createCloudflareBuilderPlugin;
+exports.getCloudflareBuilderEnvironments = __webpack_exports__.getCloudflareBuilderEnvironments;
+exports.getCloudflareWorkerRspackConfig = __webpack_exports__.getCloudflareWorkerRspackConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyCloudflareBuilderEnvironments",
+    "applyCloudflareWorkerMfRuntimeBoundary",
+    "applyCloudflareWorkerRspackConfig",
+    "createCloudflareBuilderPlugin",
+    "getCloudflareBuilderEnvironments",
+    "getCloudflareWorkerRspackConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare-output-contract.js

@@ -0,0 +1,108 @@
+"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 CLOUDFLARE_WORKER_ENTRY = 'server/index.mjs';
+const CLOUDFLARE_WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const CLOUDFLARE_WRANGLER_CONFIG_FILE = 'wrangler.json';
+const CLOUDFLARE_OUTPUT_PACKAGE_FILE = 'package.json';
+const CLOUDFLARE_WORKER_PACKAGE_FILE = 'worker/package.json';
+const CLOUDFLARE_ASSETS_BINDING = 'ASSETS';
+const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = 'public';
+const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = 'worker';
+const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
+const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
+const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
+const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
+const CLOUDFLARE_WORKER_NODE_BUILTINS = [
+    'async_hooks',
+    'buffer',
+    'crypto',
+    'events',
+    'fs/promises',
+    'module',
+    'path',
+    'process',
+    'stream',
+    'string_decoder',
+    'url',
+    'util'
+];
+const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
+    'nodejs_compat',
+    'global_fetch_strictly_public'
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    CLOUDFLARE_ASSETS_BINDING: CLOUDFLARE_ASSETS_BINDING,
+    CLOUDFLARE_OUTPUT_PACKAGE_FILE: CLOUDFLARE_OUTPUT_PACKAGE_FILE,
+    CLOUDFLARE_OUTPUT_PACKAGE_TYPE: CLOUDFLARE_OUTPUT_PACKAGE_TYPE,
+    CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY: CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY,
+    CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS: CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS,
+    CLOUDFLARE_RUNTIME_TYPE: CLOUDFLARE_RUNTIME_TYPE,
+    CLOUDFLARE_WORKER_BUNDLE_DIRECTORY: CLOUDFLARE_WORKER_BUNDLE_DIRECTORY,
+    CLOUDFLARE_WORKER_BUNDLE_FORMAT: CLOUDFLARE_WORKER_BUNDLE_FORMAT,
+    CLOUDFLARE_WORKER_ENTRY: CLOUDFLARE_WORKER_ENTRY,
+    CLOUDFLARE_WORKER_MANIFEST: CLOUDFLARE_WORKER_MANIFEST,
+    CLOUDFLARE_WORKER_NODE_BUILTINS: CLOUDFLARE_WORKER_NODE_BUILTINS,
+    CLOUDFLARE_WORKER_PACKAGE_FILE: CLOUDFLARE_WORKER_PACKAGE_FILE,
+    CLOUDFLARE_WORKER_PACKAGE_TYPE: CLOUDFLARE_WORKER_PACKAGE_TYPE,
+    CLOUDFLARE_WRANGLER_CONFIG_FILE: CLOUDFLARE_WRANGLER_CONFIG_FILE
+});
+exports.CLOUDFLARE_ASSETS_BINDING = __webpack_exports__.CLOUDFLARE_ASSETS_BINDING;
+exports.CLOUDFLARE_OUTPUT_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+exports.CLOUDFLARE_OUTPUT_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_OUTPUT_PACKAGE_TYPE;
+exports.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+exports.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = __webpack_exports__.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+exports.CLOUDFLARE_RUNTIME_TYPE = __webpack_exports__.CLOUDFLARE_RUNTIME_TYPE;
+exports.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+exports.CLOUDFLARE_WORKER_BUNDLE_FORMAT = __webpack_exports__.CLOUDFLARE_WORKER_BUNDLE_FORMAT;
+exports.CLOUDFLARE_WORKER_ENTRY = __webpack_exports__.CLOUDFLARE_WORKER_ENTRY;
+exports.CLOUDFLARE_WORKER_MANIFEST = __webpack_exports__.CLOUDFLARE_WORKER_MANIFEST;
+exports.CLOUDFLARE_WORKER_NODE_BUILTINS = __webpack_exports__.CLOUDFLARE_WORKER_NODE_BUILTINS;
+exports.CLOUDFLARE_WORKER_PACKAGE_FILE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_FILE;
+exports.CLOUDFLARE_WORKER_PACKAGE_TYPE = __webpack_exports__.CLOUDFLARE_WORKER_PACKAGE_TYPE;
+exports.CLOUDFLARE_WRANGLER_CONFIG_FILE = __webpack_exports__.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_ASSETS_BINDING",
+    "CLOUDFLARE_OUTPUT_PACKAGE_FILE",
+    "CLOUDFLARE_OUTPUT_PACKAGE_TYPE",
+    "CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY",
+    "CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS",
+    "CLOUDFLARE_RUNTIME_TYPE",
+    "CLOUDFLARE_WORKER_BUNDLE_DIRECTORY",
+    "CLOUDFLARE_WORKER_BUNDLE_FORMAT",
+    "CLOUDFLARE_WORKER_ENTRY",
+    "CLOUDFLARE_WORKER_MANIFEST",
+    "CLOUDFLARE_WORKER_NODE_BUILTINS",
+    "CLOUDFLARE_WORKER_PACKAGE_FILE",
+    "CLOUDFLARE_WORKER_PACKAGE_TYPE",
+    "CLOUDFLARE_WRANGLER_CONFIG_FILE"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cloudflare-output-plan.js

@@ -0,0 +1,93 @@
+"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__, {
+    createCloudflareOutputPlan: ()=>createCloudflareOutputPlan
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
+const resolveOutput = (outputDirectory, relativePath)=>external_node_path_default().join(outputDirectory, relativePath);
+function createCloudflareOutputPlan(outputDirectory) {
+    return {
+        outputDirectory,
+        requiredFiles: [
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_MANIFEST,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE,
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE
+        ],
+        publicLeakDirectories: [
+            'server',
+            external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY
+        ],
+        paths: {
+            workerEntry: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY),
+            workerManifest: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_MANIFEST),
+            wranglerConfig: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE),
+            outputPackage: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE),
+            workerPackage: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PACKAGE_FILE),
+            publicAssets: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY),
+            workerBundle: resolveOutput(outputDirectory, external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY)
+        },
+        packages: {
+            output: {
+                type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_TYPE
+            },
+            worker: {
+                type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_PACKAGE_TYPE
+            }
+        },
+        wrangler: {
+            main: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY,
+            assets: {
+                binding: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING,
+                directory: `./${external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`,
+                run_worker_first: true
+            },
+            requiredCompatibilityFlags: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS
+        }
+    };
+}
+exports.createCloudflareOutputPlan = __webpack_exports__.createCloudflareOutputPlan;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCloudflareOutputPlan"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});