@effected/tsconfig-json 0.1.0

package/TsconfigLoader.js

@@ -0,0 +1,160 @@
+import { ResolvedTsconfig } from "./ResolvedTsconfig.js";
+import { TsconfigJsonFromString, TsconfigParseError } from "./TsconfigJson.js";
+import { resolveExtendsTarget } from "./internal/extendsTarget.js";
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
+
+//#region src/TsconfigLoader.ts
+/**
+* The maximum number of `extends` levels the loader will descend before failing
+* with {@link TsconfigExtendsError} `reason: "depth"`. A guard on the recursive
+* walk over untrusted config files, not a tsc limit.
+*/
+const MAX_EXTENDS_DEPTH = 32;
+/**
+* Raised when a config's `extends` chain cannot be resolved: an unresolvable
+* target (`"not-found"`), a re-entrant chain (`"cycle"`), a chain deeper than
+* `MAX_EXTENDS_DEPTH` (`"depth"`), or an empty target string (`"empty"`).
+* `path` is the config whose `extends` failed, `target` is what it tried to
+* extend (the offending spec for `"not-found"`/`"empty"`, the re-entered config
+* path for `"cycle"`, the refused config for `"depth"`), and `chain` is the full
+* resolution chain of normalized absolute paths.
+*
+* @public
+*/
+var TsconfigExtendsError = class extends Schema.TaggedErrorClass()("TsconfigExtendsError", {
+	/** The config whose `extends` could not be resolved. */
+	path: Schema.String,
+	/** The target that failed: the spec, the re-entered path, or the refused path. */
+	target: Schema.String,
+	/** Why resolution failed. */
+	reason: Schema.Literals([
+		"not-found",
+		"cycle",
+		"depth",
+		"empty"
+	]),
+	/** The full resolution chain of normalized absolute config paths. */
+	chain: Schema.Array(Schema.String)
+}) {
+	get message() {
+		return this.reason === "not-found" ? `cannot resolve extends target "${this.target}" from "${this.path}"` : this.reason === "cycle" ? `extends cycle re-entering "${this.target}" via ${this.chain.join(" -> ")}` : this.reason === "depth" ? `extends chain exceeded depth ${MAX_EXTENDS_DEPTH} at "${this.path}"` : `empty extends target in "${this.path}"`;
+	}
+};
+/** tsc normalizes to forward slashes throughout; the merge engine and the cycle keys assume that convention. */
+const normalizeSlashes = (p) => p.replace(/\\/g, "/");
+/** The shared JSONC decode entrypoint (`TsconfigJsonFromString` is already the shared codec instance). */
+const decodeConfig = Schema.decodeEffect(TsconfigJsonFromString);
+/** Normalize a config's `extends` field (absent / string / array) to an ordered spec list. */
+const extendsSpecs = (doc) => {
+	const ext = doc.extends;
+	if (ext === void 0) return [];
+	return typeof ext === "string" ? [ext] : ext;
+};
+/** Read + decode one config at an already-absolute, normalized path; wrap decode failures with that path. */
+const loadAbs = (abs) => Effect.gen(function* () {
+	const text = yield* (yield* FileSystem.FileSystem).readFileString(abs);
+	return yield* decodeConfig(text).pipe(Effect.mapError((cause) => TsconfigParseError.make({
+		path: abs,
+		cause
+	})));
+});
+/**
+* Read one config file and decode it through {@link TsconfigJsonFromString}. A
+* decode failure is wrapped in a {@link TsconfigParseError} carrying the file's
+* absolute path; a `PlatformError` from the read flows through untranslated. No
+* `extends` resolution — {@link TsconfigLoader.resolve} drives that.
+*
+* @public
+*/
+const load = (configPath) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	return yield* loadAbs(normalizeSlashes(path.resolve(configPath)));
+});
+/**
+* Collect the flattened, base-most-first list of absolutized config documents
+* for `configPath` and its full `extends` chain. `chain` is the stack of
+* already-visited normalized absolute paths on THIS branch (copied per branch,
+* so a diamond is legal); it excludes `configPath` itself until it is admitted.
+*/
+const collect = (configPath, chain) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const abs = normalizeSlashes(path.resolve(configPath));
+	if (chain.length >= MAX_EXTENDS_DEPTH) return yield* Effect.fail(TsconfigExtendsError.make({
+		path: abs,
+		target: abs,
+		reason: "depth",
+		chain: [...chain, abs]
+	}));
+	const doc = yield* loadAbs(abs);
+	const absolutized = ResolvedTsconfig.absolutize(doc, path.dirname(abs), path.resolve);
+	const newChain = [...chain, abs];
+	const layers = [];
+	for (const spec of extendsSpecs(absolutized)) {
+		if (spec === "") return yield* Effect.fail(TsconfigExtendsError.make({
+			path: abs,
+			target: "",
+			reason: "empty",
+			chain: newChain
+		}));
+		const target = yield* resolveExtendsTarget(spec, abs);
+		if (Option.isNone(target)) return yield* Effect.fail(TsconfigExtendsError.make({
+			path: abs,
+			target: spec,
+			reason: "not-found",
+			chain: newChain
+		}));
+		const normTarget = normalizeSlashes(target.value);
+		if (newChain.includes(normTarget)) return yield* Effect.fail(TsconfigExtendsError.make({
+			path: abs,
+			target: normTarget,
+			reason: "cycle",
+			chain: [...newChain, normTarget]
+		}));
+		const subLayers = yield* collect(normTarget, newChain);
+		for (const sub of subLayers) layers.push(sub);
+	}
+	layers.push({
+		doc: absolutized,
+		path: abs
+	});
+	return layers;
+});
+/**
+* Resolve a tsconfig.json and its full `extends` chain into a
+* {@link (ResolvedTsconfig:interface)}: load and decode each config, absolutize its path
+* options (E5), resolve `extends` depth-first with per-branch cycle and depth
+* guards (E1-E3, E6), fold the chain own-config-last (E4), then substitute a
+* leading `${configDir}` once against the top config's directory (E5 final
+* phase). `configPath` + `extendedPaths` come back base-most first, own config
+* last. Every failure is a typed error — `TsconfigParseError` (a malformed file,
+* carrying that file's path), `TsconfigExtendsError` (a broken chain), or a
+* `PlatformError` from IO — never a defect.
+*
+* @public
+*/
+const resolve = (configPath) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const topAbs = normalizeSlashes(path.resolve(configPath));
+	const layers = yield* collect(topAbs, []);
+	let acc = {
+		configPath: topAbs,
+		extendedPaths: [],
+		compilerOptions: {}
+	};
+	for (const entry of layers) acc = ResolvedTsconfig.merge(acc, entry.doc, entry.path);
+	return ResolvedTsconfig.substituteConfigDir(acc, path.dirname(topAbs));
+});
+/**
+* The tsconfig.json loader: {@link TsconfigLoader.load} reads and decodes one
+* config file, {@link TsconfigLoader.resolve} runs the full load -\> extends -\>
+* merge -\> `${configDir}` pipeline.
+*
+* @public
+*/
+const TsconfigLoader = {
+	load,
+	resolve
+};
+
+//#endregion
+export { TsconfigExtendsError, TsconfigLoader };