@savvy-web/tsdown-plugins 0.1.0

package/dts/resolved-tsconfig.js

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+//#region src/dts/resolved-tsconfig.ts
+/** Build the portable absolute-path tsconfig object (ported from rslib writeBundleTempConfig). */
+function buildResolvedTsconfig(options) {
+	const cwd = options.cwd;
+	return {
+		compilerOptions: {
+			declaration: true,
+			emitDeclarationOnly: false,
+			declarationMap: true,
+			rootDir: cwd,
+			outDir: join(cwd, "dist"),
+			declarationDir: join(cwd, "dist"),
+			typeRoots: [join(cwd, "node_modules/@types"), join(cwd, "types")],
+			types: options.types ? [...options.types] : ["node"],
+			composite: false,
+			incremental: false,
+			tsBuildInfoFile: void 0,
+			...options.jsx !== void 0 ? { jsx: options.jsx } : {},
+			...options.jsxImportSource !== void 0 ? { jsxImportSource: options.jsxImportSource } : {}
+		},
+		include: [
+			join(cwd, "src/**/*.ts"),
+			join(cwd, "src/**/*.mts"),
+			join(cwd, "src/**/*.tsx"),
+			join(cwd, "types/*.ts"),
+			join(cwd, "package.json")
+		],
+		exclude: [join(cwd, "node_modules"), join(cwd, "dist/**/*")]
+	};
+}
+/** Write the resolved tsconfig to a temp file and return its absolute path. */
+function writeResolvedTsconfig(options) {
+	const cfg = buildResolvedTsconfig(options);
+	const path = join(tmpdir(), `tsconfig-bundle-${process.pid}-${options.cwd.replace(/[^\w]/g, "_")}.json`);
+	writeFileSync(path, `${JSON.stringify(cfg, null, "	")}\n`, "utf-8");
+	return path;
+}
+
+//#endregion
+export { buildResolvedTsconfig, writeResolvedTsconfig };

package/entry/extract.js

@@ -0,0 +1,68 @@
+//#region src/entry/extract.ts
+const isTypeScriptFile = (p) => p.endsWith(".ts") || p.endsWith(".tsx");
+/** /dist/*.js to /src/*.ts; otherwise unchanged. */
+const resolveToTypeScript = (p) => p.endsWith(".js") && p.includes("/dist/") ? p.replace("/dist/", "/src/").replace(/\.js$/, ".ts") : p;
+/** Resolve an export value to a source path: import || default || types (NOT require). */
+const resolveSourcePath = (value) => {
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object") {
+		const o = value;
+		return o.import || o.default || o.types || void 0;
+	}
+};
+/**
+* Map an export key to the tsdown entry name (the emitted output basename).
+*
+* `.` becomes `index`; otherwise the leading `./` is stripped and, unless
+* `exportsAsIndexes` is set, nested slashes are flattened to dashes
+* (e.g. `./changesets/markdownlint` to `changesets-markdownlint`). The manifest
+* transform reuses this so the declared output path always matches the emitted file.
+*
+* @internal
+*/
+const createEntryName = (exportKey, exportsAsIndexes) => {
+	if (exportKey === ".") return "index";
+	const withoutPrefix = exportKey.replace(/^\.\//, "");
+	return exportsAsIndexes ? `${withoutPrefix}/index` : withoutPrefix.replace(/\//g, "-");
+};
+function extractEntries(pkg, options = {}) {
+	const entries = {};
+	const exportPaths = {};
+	const exportsAsIndexes = options.exportsAsIndexes ?? false;
+	const exports = pkg.exports;
+	if (typeof exports === "string") {
+		if (isTypeScriptFile(exports)) {
+			entries.index = exports;
+			exportPaths.index = ".";
+		}
+	} else if (exports && typeof exports === "object") for (const [key, value] of Object.entries(exports)) {
+		if (key === "./package.json" || key.endsWith(".json")) continue;
+		const sourcePath = resolveSourcePath(value);
+		if (!sourcePath) continue;
+		const resolved = resolveToTypeScript(sourcePath);
+		if (!isTypeScriptFile(resolved)) continue;
+		const name = createEntryName(key, exportsAsIndexes);
+		if (name in entries) {
+			const previousKey = exportPaths[name];
+			throw new Error(`Export key "${key}" flattens to entry name "${name}", which collides with export key "${previousKey}". Rename one of the conflicting exports so each produces a distinct entry name.`);
+		}
+		entries[name] = resolved;
+		exportPaths[name] = key;
+	}
+	const bin = pkg.bin;
+	if (typeof bin === "string") {
+		const resolved = resolveToTypeScript(bin);
+		if (isTypeScriptFile(resolved)) entries["bin/cli"] = resolved;
+	} else if (bin && typeof bin === "object") for (const [command, p] of Object.entries(bin)) {
+		if (typeof p !== "string") continue;
+		const resolved = resolveToTypeScript(p);
+		if (isTypeScriptFile(resolved)) entries[`bin/${command}`] = resolved;
+	}
+	return {
+		entries,
+		exportPaths
+	};
+}
+
+//#endregion
+export { createEntryName, extractEntries };

package/entry/package-json-entries.js

@@ -0,0 +1,12 @@
+import { extractEntries } from "./extract.js";
+import { resolve } from "node:path";
+import { readFileSync } from "node:fs";
+
+//#region src/entry/package-json-entries.ts
+/** Derive a tsdown `entry` record (name to source path) from a package.json. */
+function packageJsonEntries(options = {}) {
+	return extractEntries(options.pkg ?? JSON.parse(readFileSync(resolve(options.cwd ?? process.cwd(), "package.json"), "utf-8")), { exportsAsIndexes: options.exportsAsIndexes }).entries;
+}
+
+//#endregion
+export { packageJsonEntries };

package/errors.js

@@ -0,0 +1,36 @@
+import { Data } from "effect";
+
+//#region src/errors.ts
+/** Entry derivation from package.json failed. */
+var EntryDetectionError = class extends Data.TaggedError("EntryDetectionError") {
+	get message() {
+		return `Entry detection failed: ${this.reason}`;
+	}
+};
+/** Emitting the transformed manifest failed. */
+var ManifestEmitError = class extends Data.TaggedError("ManifestEmitError") {
+	get message() {
+		return `Manifest emit failed: ${this.reason}`;
+	}
+};
+/** The tsdown build for a TargetGroup failed. */
+var BuildFailed = class extends Data.TaggedError("BuildFailed") {
+	get message() {
+		return `Build failed for TargetGroup "${this.targetGroup}": ${this.reason}`;
+	}
+};
+/** API Extractor meta generation failed for an entry. */
+var MetaGenerationError = class extends Data.TaggedError("MetaGenerationError") {
+	get message() {
+		return `Meta generation failed for entry "${this.entry}": ${this.reason}`;
+	}
+};
+/** A savvy.build.ts or publishConfig.targets config is structurally invalid; raised before any build work. */
+var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+	get message() {
+		return `Config validation failed at "${this.path}": ${this.reason}`;
+	}
+};
+
+//#endregion
+export { ConfigValidationError, MetaGenerationError };

package/exe/build.js

@@ -0,0 +1,23 @@
+//#region src/exe/build.ts
+/** Compile each SEA binary via tsdown's exe mode. One tsdown build per spec. */
+async function runExeBuild(options) {
+	const build = options.build ?? (await import("tsdown")).build;
+	for (const spec of options.specs) await build({
+		cwd: options.cwd,
+		config: false,
+		entry: [spec.entry],
+		format: "esm",
+		platform: "node",
+		clean: false,
+		deps: { alwaysBundle: (id) => !id.startsWith("node:") },
+		exe: {
+			fileName: spec.fileName,
+			outDir: options.outDir,
+			seaConfig: spec.seaConfig,
+			targets: spec.targets
+		}
+	});
+}
+
+//#endregion
+export { runExeBuild };

package/exe/config.js

@@ -0,0 +1,50 @@
+//#region src/exe/config.ts
+/** Default Node runtime embedded in the SEA (parity with the vitest-agent reference). */
+const DEFAULT_EXE_NODE_VERSION = "25.9.0";
+/** Map a package.json os value to the tsdown exe platform token. */
+function platformToken(os) {
+	if (os === "darwin") return "darwin";
+	if (os === "linux") return "linux";
+	if (os === "win32") return "win";
+}
+/** Infer the default targets from the package's os/cpu (the zero-config, one-platform-per-package case). */
+function inferTargets(pkg) {
+	const os = pkg.os[0];
+	const cpu = pkg.cpu[0];
+	if (os === void 0 || cpu === void 0) return [];
+	const platform = platformToken(os);
+	if (platform === void 0 || cpu !== "arm64" && cpu !== "x64") return [];
+	return [{
+		platform,
+		arch: cpu
+	}];
+}
+/**
+* Normalize `exe` (object or array) into one fully-resolved spec per binary.
+*
+* Pure function; structural validation (missing fileName, empty targets) lives in the
+* config-validation layer.
+*/
+function normalizeExeOptions(exe, pkg) {
+	return (Array.isArray(exe) ? exe : [exe]).map((c) => {
+		const nodeVersion = c.nodeVersion ?? "25.9.0";
+		const targetInputs = c.targets ?? inferTargets(pkg);
+		return {
+			fileName: c.fileName,
+			entry: c.entry ?? "./src/bin.ts",
+			targets: targetInputs.map((t) => ({
+				platform: t.platform,
+				arch: t.arch,
+				nodeVersion
+			})),
+			seaConfig: {
+				disableExperimentalSEAWarning: c.seaConfig?.disableExperimentalSEAWarning ?? true,
+				useCodeCache: c.seaConfig?.useCodeCache ?? false,
+				useSnapshot: c.seaConfig?.useSnapshot ?? false
+			}
+		};
+	});
+}
+
+//#endregion
+export { DEFAULT_EXE_NODE_VERSION, normalizeExeOptions };