@qzsy/vinext 0.1.7

package/dist/config/tsconfig-paths.d.ts

@@ -0,0 +1,21 @@
+//#region src/config/tsconfig-paths.d.ts
+type TsconfigPathResolution = {
+  aliases: Record<string, string>;
+  baseUrl: string | null;
+};
+/**
+ * Read the project's tsconfig.json (or jsconfig.json) and return its
+ * path-resolution settings as absolute paths.
+ *
+ * Returns an empty resolution if no config is found or no relevant compiler
+ * options are configured.
+ * Errors during parsing are swallowed — this is a best-effort helper that
+ * must not break config loading.
+ */
+declare function loadTsconfigResolutionForRoot(projectRoot: string): TsconfigPathResolution;
+/**
+ * Back-compat helper for call sites that only need `compilerOptions.paths`.
+ */
+declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
+//#endregion
+export { loadTsconfigPathAliasesForRoot, loadTsconfigResolutionForRoot };

package/dist/config/tsconfig-paths.js

@@ -0,0 +1,157 @@
+import { isUnknownRecord } from "../utils/record.js";
+import { parseStaticObjectLiteral } from "../plugins/fonts.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/config/tsconfig-paths.ts
+/**
+* tsconfig.json `compilerOptions.paths` loader.
+*
+* Used to make tsconfig path aliases (e.g. `@/foo` mapping to `./src/foo`)
+* and `baseUrl` bare imports available when vinext loads `next.config.ts`
+* through Vite's `runnerImport`.
+*
+* Next.js's own `next.config.ts` loader (packages/next/src/build/next-config-ts/
+* transpile-config.ts) reads `compilerOptions.paths` and
+* `compilerOptions.baseUrl` from the project's `tsconfig.json` and passes them
+* to SWC so that imports like
+* `import { foo } from '@/foo'` and `import { bar } from 'bar'` resolve at
+* config load time. We do the same here with Vite resolver settings.
+*
+* The implementation is intentionally minimal:
+*   - Static JSON-style parse of tsconfig.json (handles trailing commas /
+*     comments via the shared `parseStaticObjectLiteral` helper)
+*   - `extends` is followed up to a small recursion depth, with cycle
+*     detection — matches the subset Next.js supports
+*   - Only the common `"@/*": ["./src/*"]` / `"@/*": ["src/*"]` pattern is
+*     supported; non-wildcard paths and exact aliases also work
+*   - Returned alias values are always absolute paths so they work with
+*     `runnerImport`'s inline environment (which has its own root).
+*/
+const TSCONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+function resolveTsconfigPathCandidate(candidate) {
+	const candidates = candidate.endsWith(".json") ? [candidate] : [
+		candidate,
+		`${candidate}.json`,
+		path.join(candidate, "tsconfig.json")
+	];
+	for (const item of candidates) if (fs.existsSync(item) && fs.statSync(item).isFile()) return item;
+	return null;
+}
+/**
+* Normalize a tsconfig `extends` field into a list of specifier strings.
+*
+* TypeScript 5.0+ allows `extends` to be either a string or an array of
+* strings. Matches Next.js's handling in
+* packages/next/src/build/next-config-ts/transpile-config.ts, where parents
+* are iterated in order and later entries override earlier ones.
+*/
+function normalizeExtends(extendsField) {
+	if (typeof extendsField === "string") return [extendsField];
+	if (Array.isArray(extendsField)) return extendsField.filter((value) => typeof value === "string");
+	return [];
+}
+function resolveTsconfigExtends(configPath, specifier) {
+	const fromDir = path.dirname(configPath);
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\\")) return resolveTsconfigPathCandidate(path.resolve(fromDir, specifier));
+	const requireFromConfig = createRequire(configPath);
+	const candidates = [
+		specifier,
+		`${specifier}.json`,
+		path.join(specifier, "tsconfig.json")
+	];
+	for (const item of candidates) try {
+		return requireFromConfig.resolve(item);
+	} catch {}
+	return null;
+}
+function materializeAliases(pathsConfig, baseUrl) {
+	const aliases = {};
+	for (const [find, rawTargets] of Object.entries(pathsConfig)) {
+		const target = Array.isArray(rawTargets) ? rawTargets.find((value) => typeof value === "string") : typeof rawTargets === "string" ? rawTargets : null;
+		if (!target) continue;
+		if (find.includes("*") || target.includes("*")) {
+			if (!find.endsWith("/*") || !target.endsWith("/*")) continue;
+			if (find.indexOf("*") !== find.length - 1 || target.indexOf("*") !== target.length - 1) continue;
+			const aliasKey = find.slice(0, -2);
+			const targetDir = target.slice(0, -2);
+			if (!aliasKey || !targetDir) continue;
+			aliases[aliasKey] = path.resolve(baseUrl, targetDir);
+			continue;
+		}
+		aliases[find] = path.resolve(baseUrl, target);
+	}
+	return aliases;
+}
+function emptyResolution() {
+	return {
+		aliases: {},
+		baseUrl: null
+	};
+}
+function loadResolutionFromTsconfigFile(configPath, seen) {
+	if (seen.has(configPath)) return emptyResolution();
+	seen.add(configPath);
+	let parsed = null;
+	try {
+		parsed = parseStaticObjectLiteral(fs.readFileSync(configPath, "utf-8"));
+	} catch {
+		return emptyResolution();
+	}
+	if (!parsed) return emptyResolution();
+	let resolution = emptyResolution();
+	const extendsList = normalizeExtends(parsed.extends);
+	for (const extendsSpecifier of extendsList) {
+		const extendedPath = resolveTsconfigExtends(configPath, extendsSpecifier);
+		if (extendedPath) {
+			const parent = loadResolutionFromTsconfigFile(extendedPath, seen);
+			resolution = {
+				aliases: {
+					...resolution.aliases,
+					...parent.aliases
+				},
+				baseUrl: parent.baseUrl ?? resolution.baseUrl
+			};
+		}
+	}
+	const compilerOptions = isUnknownRecord(parsed.compilerOptions) ? parsed.compilerOptions : null;
+	const baseUrl = (compilerOptions && typeof compilerOptions.baseUrl === "string" ? path.resolve(path.dirname(configPath), compilerOptions.baseUrl) : null) ?? resolution.baseUrl;
+	const pathsConfig = compilerOptions && isUnknownRecord(compilerOptions.paths) ? compilerOptions.paths : null;
+	if (!pathsConfig) return {
+		aliases: resolution.aliases,
+		baseUrl
+	};
+	const pathsBaseUrl = baseUrl ?? path.dirname(configPath);
+	return {
+		aliases: {
+			...resolution.aliases,
+			...materializeAliases(pathsConfig, pathsBaseUrl)
+		},
+		baseUrl
+	};
+}
+/**
+* Read the project's tsconfig.json (or jsconfig.json) and return its
+* path-resolution settings as absolute paths.
+*
+* Returns an empty resolution if no config is found or no relevant compiler
+* options are configured.
+* Errors during parsing are swallowed — this is a best-effort helper that
+* must not break config loading.
+*/
+function loadTsconfigResolutionForRoot(projectRoot) {
+	for (const name of TSCONFIG_FILES) {
+		const candidate = path.join(projectRoot, name);
+		if (!fs.existsSync(candidate)) continue;
+		return loadResolutionFromTsconfigFile(candidate, /* @__PURE__ */ new Set());
+	}
+	return emptyResolution();
+}
+/**
+* Back-compat helper for call sites that only need `compilerOptions.paths`.
+*/
+function loadTsconfigPathAliasesForRoot(projectRoot) {
+	return loadTsconfigResolutionForRoot(projectRoot).aliases;
+}
+//#endregion
+export { loadTsconfigPathAliasesForRoot, loadTsconfigResolutionForRoot };

package/dist/deploy.d.ts

@@ -0,0 +1,190 @@
+import { ensureESModule as ensureESModule$1, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
+import { execFileSync } from "node:child_process";
+
+//#region src/deploy.d.ts
+type DeployOptions = {
+  /** Project root directory */root: string; /** Deploy to preview environment (default: production) */
+  preview?: boolean; /** Wrangler environment name from wrangler.jsonc env.<name> */
+  env?: string; /** Custom project name for the Worker */
+  name?: string; /** Skip the build step (assume already built) */
+  skipBuild?: boolean; /** Dry run — generate config files but don't build or deploy */
+  dryRun?: boolean; /** Pre-render all discovered routes into the dist output after building */
+  prerenderAll?: boolean; /** Maximum number of routes to prerender in parallel */
+  prerenderConcurrency?: number; /** Enable experimental TPR (Traffic-aware Pre-Rendering) */
+  experimentalTPR?: boolean; /** TPR: traffic coverage percentage target (0–100, default: 90) */
+  tprCoverage?: number; /** TPR: hard cap on number of pages to pre-render (default: 1000) */
+  tprLimit?: number; /** TPR: analytics lookback window in hours (default: 24) */
+  tprWindow?: number;
+};
+declare function parseDeployArgs(args: string[]): {
+  help: boolean;
+  preview: boolean;
+  env: string | undefined;
+  name: string | undefined;
+  skipBuild: boolean;
+  dryRun: boolean;
+  prerenderAll: boolean;
+  prerenderConcurrency: number | undefined;
+  experimentalTPR: boolean;
+  tprCoverage: number | undefined;
+  tprLimit: number | undefined;
+  tprWindow: number | undefined;
+};
+type ProjectInfo = {
+  root: string;
+  isAppRouter: boolean;
+  isPagesRouter: boolean;
+  hasViteConfig: boolean;
+  hasWranglerConfig: boolean;
+  hasWorkerEntry: boolean;
+  hasCloudflarePlugin: boolean;
+  hasRscPlugin: boolean;
+  hasWrangler: boolean;
+  projectName: string; /** Pages that use `revalidate` (ISR) */
+  hasISR: boolean; /** package.json has "type": "module" */
+  hasTypeModule: boolean; /** .mdx files detected in app/ or pages/ */
+  hasMDX: boolean; /** CodeHike is a dependency */
+  hasCodeHike: boolean; /** Native Node modules that need stubbing for Workers */
+  nativeModulesToStub: string[];
+};
+/** Check whether a wrangler config file exists in the given directory. */
+declare function hasWranglerConfig(root: string): boolean;
+/**
+ * Build the error message thrown when cloudflare() is missing from the Vite config.
+ * Shared between the build-time guard (index.ts configResolved) and the
+ * deploy-time guard (deploy.ts deploy()).
+ */
+declare function formatMissingCloudflarePluginError(options: {
+  isAppRouter: boolean;
+  configFile?: string;
+}): string;
+declare function detectProject(root: string): ProjectInfo;
+/** @see {@link _ensureESModule} */
+declare const ensureESModule: typeof ensureESModule$1;
+/** @see {@link _renameCJSConfigs} */
+declare const renameCJSConfigs: typeof renameCJSConfigs$1;
+/** Generate wrangler.jsonc content */
+declare function generateWranglerConfig(info: ProjectInfo): string;
+/** Generate worker/index.ts for App Router */
+declare function generateAppRouterWorkerEntry(): string;
+/** Generate worker/index.ts for Pages Router */
+declare function generatePagesRouterWorkerEntry(): string;
+/** Generate vite.config.ts for App Router */
+declare function generateAppRouterViteConfig(info?: ProjectInfo): string;
+/** Generate vite.config.ts for Pages Router */
+declare function generatePagesRouterViteConfig(info?: ProjectInfo): string;
+type MissingDep = {
+  name: string;
+  version: string;
+};
+/**
+ * Check if a package is resolvable from a given root directory using
+ * Node's module resolution (createRequire). Handles hoisting, pnpm
+ * symlinks, monorepos, and Yarn PnP correctly.
+ */
+declare function isPackageResolvable(root: string, packageName: string): boolean;
+declare function getMissingDeps(info: ProjectInfo, /** Override for testing — defaults to `isPackageResolvable` */
+
+_isResolvable?: (root: string, pkg: string) => boolean): MissingDep[];
+type GeneratedFile = {
+  path: string;
+  content: string;
+  description: string;
+};
+/**
+ * Check whether an existing vite.config file already imports and uses the
+ * Cloudflare Vite plugin. This is a heuristic text scan — it doesn't execute
+ * the config — so it may produce false negatives for unusual configurations.
+ *
+ * Returns true if `@cloudflare/vite-plugin` appears to be configured, false
+ * if it is missing (meaning the build will fail with "could not resolve
+ * virtual:vinext-rsc-entry").
+ */
+declare function viteConfigHasCloudflarePlugin(root: string): boolean;
+/**
+ * Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
+ * `cdn` or `data` field of the `vinext({ cache })` option is given a value.
+ * This is a source-level check on those exact object fields, not a fuzzy scan
+ * for adapter names. Mirrors {@link viteConfigHasCloudflarePlugin}'s leniency:
+ * an unreadable or absent config is treated as configured so a deploy is never
+ * blocked on a false negative.
+ */
+declare function viteConfigHasCacheAdapter(root: string): boolean;
+/**
+ * Detect whether an existing user-authored Worker entry wires up a cache
+ * backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
+ * / `setCdnCacheAdapter` setters. These setters are deprecated in favour of the
+ * declarative `vinext({ cache })` option, but older apps that scaffolded a KV
+ * cache handler into their Worker entry must keep working — so a deploy should
+ * not be blocked when the Worker entry already configures a backend.
+ *
+ * This is a heuristic text scan (it doesn't execute the entry), mirroring
+ * {@link viteConfigHasCacheAdapter}'s leniency: an unreadable Worker entry is
+ * treated as configured so a deploy is never blocked on a false negative. A
+ * missing Worker entry returns false (nothing to inspect — defer to other
+ * checks).
+ */
+declare function workerEntryHasCacheHandler(root: string): boolean;
+/**
+ * Build the error thrown when an ISR/cached app is deployed without a cache
+ * adapter configured in the Vite config. Production deployments need a
+ * persistent cache backend; vinext no longer scaffolds one into the Worker
+ * entry, so it must be declared via `vinext({ cache })`.
+ */
+declare function formatMissingCacheAdapterError(options: {
+  configFile?: string;
+}): string;
+declare function getFilesToGenerate(info: ProjectInfo): GeneratedFile[];
+/**
+ * Run a function with `process.env.CLOUDFLARE_ENV` set to the given value,
+ * restoring the previous state (whether set or absent) after the function
+ * resolves or throws.
+ *
+ * The `@cloudflare/vite-plugin` reads `CLOUDFLARE_ENV` from `process.env` to
+ * drive the multi-environment merge applied to the emitted `wrangler.json`.
+ * Without this propagation the `--env <name>` CLI flag is silently ignored at
+ * build time and the top-level config is emitted regardless. See issue #1210.
+ *
+ * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
+ */
+declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
+type WranglerDeployArgs = {
+  args: string[];
+  env: string | undefined;
+};
+declare function validateWranglerEnvName(env: string): string;
+declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env">): WranglerDeployArgs;
+/**
+ * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
+ *
+ * Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
+ * shim and command shell that package managers create on Windows.
+ */
+declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
+  file: string;
+  args: string[];
+};
+declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env">, nodeExecutable?: string): {
+  file: string;
+  args: string[];
+  env: string | undefined;
+};
+declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof execFileSync): string;
+/**
+ * Read the prerender manifest and inject pregenerated concrete paths into the
+ * App Router Worker bundle so the PPR fallback-shell guard is populated at
+ * module init time without calling `seedMemoryCacheFromPrerender`.
+ *
+ * The paths are injected as `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`
+ * wrapped in replaceable marker comments, and consumed by
+ * `initPregeneratedPathsFromGlobals` in the generated RSC entry.
+ *
+ * Idempotent: repeated calls strip the previous injection before writing the
+ * new one. If the manifest is missing, corrupt, or empty, any prior injection
+ * is stripped and nothing new is written — failing closed to empty.
+ */
+declare function injectPregeneratedConcretePaths(root: string): void;
+declare function deploy(options: DeployOptions): Promise<void>;
+//#endregion
+export { buildNodeCliInvocation, buildWranglerDeployArgs, buildWranglerInvocation, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, injectPregeneratedConcretePaths, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, runWranglerDeploy, validateWranglerEnvName, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };