@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/esm-node/cloudflare-output-verifier/worker-bundles.mjs

@@ -5,9 +5,9 @@ import { pathToFileURL } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
-import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS } from "../cloudflare-output-contract.mjs";
+import { CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS, CLOUDFLARE_WORKER_PLATFORM_MODULES } from "../cloudflare-output-contract.mjs";
 import { addIssue } from "./issues.mjs";
-const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
+const getReferencedRouteWorkers = (manifest, field)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.[field] && route[field].length > 0 ? route[field] : void 0).filter((worker)=>'string' == typeof worker) : [];
 const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
 const getWorkerBundleReferences = (manifest)=>{
     const effectBffWorker = getEffectBffWorker(manifest);
@@ -19,9 +19,14 @@ const getWorkerBundleReferences = (manifest)=>{
                 reference: effectBffWorker
             }
         ] : [],
-        ...getReferencedRouteWorkers(manifest).map((reference)=>({
+        ...getReferencedRouteWorkers(manifest, 'worker').map((reference)=>({
                 kind: 'route',
                 reference
+            })),
+        ...getReferencedRouteWorkers(manifest, 'routeDataWorker').map((reference)=>({
+                dispatcherExport: CLOUDFLARE_ROUTE_DATA_HANDLER_EXPORT,
+                kind: 'route-data',
+                reference
             }))
     ];
 };
@@ -42,7 +47,7 @@ const resolveWorkerBundleReference = (issues, outputDirectory, reference, manife
         path: workerPath
     };
 };
-const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
+const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'route-data' === reference.kind ? 'Cloudflare route data worker manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
 const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
 const getNodeName = (node)=>{
     if (!isAstNode(node)) return;
@@ -175,7 +180,10 @@ const analyzeWorkerModule = (source)=>{
     };
 };
 const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
+const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set([
+    ...CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`),
+    ...CLOUDFLARE_WORKER_PLATFORM_MODULES
+]);
 const isInsideDirectory = (directory, filePath)=>{
     const relative = node_path.relative(directory, filePath);
     return 0 === relative.length || !relative.startsWith('..') && !node_path.isAbsolute(relative);
@@ -283,9 +291,9 @@ const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contrac
 };
 const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
     const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
-    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
+    if ('string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
         code: 'invalid-worker-bundle',
-        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
+        message: 'route-data' === worker.kind ? `Cloudflare route data worker bundle must expose ${worker.dispatcherExport}.` : 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
         path: worker.path
     });
 };

package/dist/esm-node/config.mjs

@@ -1 +1,4 @@
 import "node:module";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler } from "./build-config/public.mjs";
+export { createRemoteManifestUrl } from "./build-config/remote-address.mjs";
+export { resolveDeployTarget } from "./deploy-output/target.mjs";

package/dist/esm-node/deploy-output/npmAliases.mjs

@@ -0,0 +1,200 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+const dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const rootDependencyKeys = [
+    ...dependencyKeys,
+    'devDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises.readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson, keys = dependencyKeys) {
+    const aliases = [];
+    for (const dependencyKey of keys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function catalogAliasesFromInstalledPackages(appDirectory, packageJson) {
+    const aliases = [];
+    for (const dependencyKey of rootDependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        if (!specifier.startsWith('catalog:')) continue;
+        let installedPackage;
+        try {
+            installedPackage = await readPackageJson(node_path.join(appDirectory, 'node_modules', aliasName, 'package.json'));
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
+        if (!installedPackage.name || !installedPackage.version) throw new Error(`Installed catalog package ${aliasName} has no identity`);
+        if (installedPackage.name !== aliasName) aliases.push({
+            aliasName,
+            targetName: installedPackage.name,
+            targetVersion: installedPackage.version
+        });
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(node_path.join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises.readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(node_path.join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises.readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = node_path.join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(node_path.join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = node_path.resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises.readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = node_path.join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = node_path.resolve(outputDirectory);
+    const resolvedOutputRoot = await promises.realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${node_path.sep}`)){
+        const candidate = node_path.join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises.realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${node_path.sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(node_path.join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = node_path.dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = node_path.join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises.mkdir(node_path.dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises.realpath(aliasPath),
+            promises.realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = node_path.relative(node_path.dirname(aliasPath), target.directory);
+    await promises.symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = node_path.dirname(entryPath);
+    const root = node_path.parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(node_path.join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = node_path.dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(node_path.join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(node_path.join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson, rootDependencyKeys),
+        ...await catalogAliasesFromInstalledPackages(appDirectory, appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = node_path.join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises.writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+export { preserveNpmAliases, readPackageIdentity };

package/dist/esm-node/deploy-output/plugin.mjs

@@ -0,0 +1,49 @@
+import "node:module";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { preserveNpmAliases, readPackageIdentity } from "./npmAliases.mjs";
+import { NODE_PUBLIC_ASSET_SCOPE, normalizeDeclaredPublicAssets, stageDeclaredPublicAssets } from "./public-assets.mjs";
+import { getDeployingTarget } from "./target.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
+const createDeployOutputAliasesPlugin = ()=>({
+        name: '@modern-js/deploy-output-aliases',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const appContext = api.getAppContext();
+                if ('node' !== getDeployingTarget(appContext)) return;
+                const { appDirectory } = appContext;
+                const entry = createRequire(__rspack_import_meta_filename__).resolve('@modern-js/prod-server');
+                const identity = await readPackageIdentity(entry);
+                await preserveNpmAliases({
+                    appDirectory,
+                    outputDirectory: node_path.join(appDirectory, '.output'),
+                    implicitAliases: [
+                        {
+                            aliasName: '@modern-js/prod-server',
+                            targetName: identity.name,
+                            targetVersion: identity.version
+                        }
+                    ]
+                });
+            });
+        }
+    });
+const createDeployOutputPublicAssetsPlugin = ()=>({
+        name: '@modern-js/deploy-output-public-assets',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const appContext = api.getAppContext();
+                if ('node' !== getDeployingTarget(appContext)) return;
+                const { appDirectory } = appContext;
+                const config = api.getNormalizedConfig();
+                await stageDeclaredPublicAssets({
+                    appDirectory,
+                    outputDirectory: node_path.join(appDirectory, '.output'),
+                    assets: normalizeDeclaredPublicAssets(config.deploy?.node?.publicAssets, NODE_PUBLIC_ASSET_SCOPE),
+                    scope: NODE_PUBLIC_ASSET_SCOPE
+                });
+            });
+        }
+    });
+export { createDeployOutputAliasesPlugin, createDeployOutputPublicAssetsPlugin };

package/dist/esm-node/deploy-output/public-assets.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { normalizeRelativePath } from "../cloudflare/utils.mjs";
+const DECLARED_PUBLIC_ASSET_DIRECTORY = 'public';
+const CLOUDFLARE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.worker.publicAssets',
+    output: 'Cloudflare public output'
+};
+const NODE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.node.publicAssets',
+    output: 'Node public output'
+};
+const normalizeDeclaredPublicAssets = (assets, scope)=>(assets ?? []).map((asset, index)=>({
+            from: normalizeRelativePath(asset?.from, `${scope.label}[${index}].from`, 'app root'),
+            to: normalizeRelativePath(asset?.to, `${scope.label}[${index}].to`, scope.output, {
+                allowRoot: true
+            }),
+            index
+        }));
+const isMissingPathError = (error)=>error instanceof Error && 'code' in error && 'ENOENT' === error.code;
+const pathExists = async (filePath)=>{
+    try {
+        await promises.lstat(filePath);
+        return true;
+    } catch (error) {
+        if (isMissingPathError(error)) return false;
+        throw error;
+    }
+};
+const listDeclaredPublicAssetFiles = async (appDirectory, assets, scope)=>{
+    const files = [];
+    const owners = new Map();
+    const add = (index, logicalPath)=>{
+        const owner = owners.get(logicalPath);
+        if (void 0 !== owner) throw new Error(`${scope.label}[${index}] and ${scope.label}[${owner}] both stage ${JSON.stringify(logicalPath)}.`);
+        owners.set(logicalPath, index);
+        files.push({
+            index,
+            logicalPath
+        });
+    };
+    const visit = async (asset, sourcePath, destination)=>{
+        const stat = await promises.lstat(sourcePath);
+        if (stat.isSymbolicLink()) throw new Error(`${scope.label}[${asset.index}].from must not contain symbolic links: ${node_path.relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        if (stat.isFile()) {
+            if (destination === DECLARED_PUBLIC_ASSET_DIRECTORY) throw new Error(`${scope.label}[${asset.index}].to must name a file when ${scope.label}[${asset.index}].from is a file.`);
+            add(asset.index, destination);
+            return;
+        }
+        if (!stat.isDirectory()) throw new Error(`${scope.label}[${asset.index}].from must contain only files and directories: ${node_path.relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        const entries = (await promises.readdir(sourcePath)).sort();
+        for (const entry of entries)await visit(asset, node_path.join(sourcePath, entry), node_path.posix.join(destination, entry));
+    };
+    for (const asset of assets){
+        const sourcePath = node_path.join(appDirectory, asset.from);
+        if (!await pathExists(sourcePath)) throw new Error(`${scope.label}[${asset.index}].from does not exist: ${asset.from}`);
+        await visit(asset, sourcePath, node_path.posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to));
+    }
+    return files;
+};
+const resolveAddedDeclaredPublicAssetPaths = async ({ appDirectory, assets, generatedRoot, scope })=>{
+    const added = [];
+    for (const file of (await listDeclaredPublicAssetFiles(appDirectory, assets, scope)))if (!await pathExists(node_path.join(generatedRoot, file.logicalPath))) added.push(file.logicalPath);
+    return added.sort();
+};
+const stageDeclaredPublicAssets = async ({ appDirectory, outputDirectory, assets, scope })=>{
+    const files = await listDeclaredPublicAssetFiles(appDirectory, assets, scope);
+    const added = [];
+    for (const file of files){
+        const asset = assets.find((candidate)=>candidate.index === file.index);
+        const relativePath = node_path.posix.relative(node_path.posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to), file.logicalPath);
+        const destination = node_path.join(outputDirectory, file.logicalPath);
+        const replacesGeneratedFile = await pathExists(destination);
+        await promises.mkdir(node_path.dirname(destination), {
+            recursive: true
+        });
+        await promises.copyFile(node_path.join(appDirectory, asset.from, relativePath), destination);
+        if (!replacesGeneratedFile) added.push(file.logicalPath);
+    }
+    return added.sort();
+};
+export { CLOUDFLARE_PUBLIC_ASSET_SCOPE, DECLARED_PUBLIC_ASSET_DIRECTORY, NODE_PUBLIC_ASSET_SCOPE, normalizeDeclaredPublicAssets, resolveAddedDeclaredPublicAssetPaths, stageDeclaredPublicAssets };

package/dist/esm-node/deploy-output/target.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import { getArgv } from "@modern-js/utils";
+import { provider as external_std_env_provider } from "std-env";
+const DEPLOY_TARGETS = [
+    'node',
+    'vercel',
+    'netlify',
+    'ghPages',
+    'cloudflare'
+];
+const DEPLOY_TARGET_FLAG = '--deploy-target';
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const readDeployTargetFlag = (argv)=>{
+    for (const [index, arg] of argv.entries()){
+        if (arg === DEPLOY_TARGET_FLAG) {
+            const value = argv[index + 1];
+            if (void 0 === value || value.startsWith('-')) throw new Error(`${DEPLOY_TARGET_FLAG} needs a value.`);
+            return value;
+        }
+        if (arg.startsWith(`${DEPLOY_TARGET_FLAG}=`)) return arg.slice(DEPLOY_TARGET_FLAG.length + 1);
+    }
+};
+const assertDeployTarget = (target, source)=>{
+    if (!DEPLOY_TARGETS.includes(target)) throw new Error(`Unknown deploy target '${target}' from ${source}. Use one of: ${DEPLOY_TARGETS.join(', ')}.`);
+    return target;
+};
+const resolveDeployTarget = ({ argv = getArgv(), configTarget, env = process.env.MODERNJS_DEPLOY, provider = external_std_env_provider } = {})=>{
+    const explicit = [
+        [
+            readDeployTargetFlag(argv),
+            DEPLOY_TARGET_FLAG
+        ],
+        [
+            configTarget,
+            'deploy.target'
+        ],
+        [
+            env,
+            'MODERNJS_DEPLOY'
+        ]
+    ].find(([target])=>target);
+    if (explicit?.[0]) return {
+        target: assertDeployTarget(explicit[0], explicit[1]),
+        explicit: true
+    };
+    return {
+        target: provider && providerDeployTargets[provider] || 'node',
+        explicit: false
+    };
+};
+const getDeployingTarget = ({ deployTarget, metaName })=>deployTarget && ('modern-js' === metaName || deployTarget.explicit) ? deployTarget.target : void 0;
+export { DEPLOY_TARGETS, DEPLOY_TARGET_FLAG, getDeployingTarget, resolveDeployTarget };

package/dist/esm-node/deploy-output/trace-files.mjs

@@ -0,0 +1,39 @@
+import "node:module";
+import node_os from "node:os";
+import node_path from "node:path";
+import { nodeFileTrace } from "@vercel/nft";
+const SYSTEM_ROOTS = 'win32' === process.platform ? [] : [
+    '/dev',
+    '/etc',
+    '/proc',
+    '/run',
+    '/sys',
+    '/var/run'
+];
+const GLOB_SEGMENT = /[*?[{]/;
+const isInside = (parent, child)=>child === parent || child.startsWith(`${parent}${node_path.sep}`);
+const globRoot = (absolutePattern)=>{
+    const { root } = node_path.parse(absolutePattern);
+    const segments = absolutePattern.slice(root.length).split(node_path.sep);
+    const index = segments.findIndex((segment)=>GLOB_SEGMENT.test(segment));
+    return -1 === index ? void 0 : node_path.join(root, ...segments.slice(0, index));
+};
+const createBuildHostIgnore = (base)=>{
+    const wholeDirectories = new Set([
+        node_path.parse(node_path.resolve(base)).root,
+        node_path.resolve(node_os.homedir()),
+        node_path.resolve(node_os.tmpdir())
+    ]);
+    return (relativePath)=>{
+        const absolutePath = node_path.resolve(base, relativePath);
+        if (SYSTEM_ROOTS.some((root)=>isInside(root, absolutePath))) return true;
+        const root = globRoot(absolutePath);
+        return void 0 !== root && wholeDirectories.has(root);
+    };
+};
+const traceDeployFiles = ({ entryFiles, sourceDir, base = '/' })=>nodeFileTrace(entryFiles, {
+        base,
+        processCwd: sourceDir,
+        ignore: createBuildHostIgnore(base)
+    });
+export { createBuildHostIgnore, traceDeployFiles };

package/dist/esm-node/native-type-checker.mjs

@@ -0,0 +1,143 @@
+import "node:module";
+import { execFile } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import node_path from "node:path";
+import { promisify } from "node:util";
+import { refreshTsgoCheckerConfig } from "@modern-js/builder";
+const execute = promisify(execFile);
+const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
+class UltramodernNativeTypeChecker {
+    async check() {
+        const { configFile, build } = this.options;
+        if (!build) {
+            const config = JSON.parse(await this.run([
+                '--showConfig',
+                '--project',
+                configFile
+            ]));
+            if (config.references?.length) await this.run([
+                '--build',
+                ...config.references.map((reference)=>node_path.resolve(node_path.dirname(configFile), reference.path)),
+                '--stopBuildOnErrors',
+                '--pretty',
+                'false'
+            ]);
+        }
+        const args = build ? [
+            '--build',
+            configFile,
+            '--stopBuildOnErrors'
+        ] : [
+            '--project',
+            configFile,
+            '--noEmit'
+        ];
+        await this.run([
+            ...args,
+            '--pretty',
+            'false'
+        ]);
+    }
+    async run(args) {
+        try {
+            const result = await execute(this.options.compiler(), args, {
+                cwd: node_path.dirname(this.options.configFile),
+                maxBuffer: 16777216
+            });
+            return result.stdout;
+        } catch (cause) {
+            const output = cause;
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
+                cause
+            });
+        }
+    }
+    async watchInputs() {
+        const inputs = new Set();
+        const missing = new Set();
+        const projects = [
+            this.options.configFile
+        ];
+        const visited = new Set();
+        for (const configFile of projects){
+            if (visited.has(configFile)) continue;
+            visited.add(configFile);
+            inputs.add(configFile);
+            if (!existsSync(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
+            const directory = node_path.dirname(configFile);
+            for (const file of config.files ?? [])inputs.add(node_path.resolve(directory, file));
+            for (const reference of config.references ?? []){
+                const target = node_path.resolve(directory, reference.path);
+                projects.push('.json' === node_path.extname(target) ? target : node_path.join(target, 'tsconfig.json'));
+            }
+        }
+        return {
+            inputs,
+            missing
+        };
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
+            compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
+                try {
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    const projectConfigFile = refreshTsgoCheckerConfig(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!existsSync(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
+                    await this.check();
+                } catch (cause) {
+                    compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
+                        cause
+                    }));
+                }
+            });
+        });
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
+    if (!chain.plugins.has(pluginId)) return;
+    const options = chain.plugin(pluginId).get('args')?.[0];
+    const typescript = options?.typescript;
+    if (typescript?.tsgo === false) return;
+    if (!typescript?.configFile) throw new Error(`${native_type_checker_name} requires the configured TypeScript project.`);
+    const configFile = node_path.resolve(typescript.configFile);
+    chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+        {
+            build: true === typescript.build,
+            compiler: ()=>resolveCompiler(configFile),
+            configFile
+        }
+    ]);
+}
+export { UltramodernNativeTypeChecker, configureUltramodernTypeChecker };