@effected/tsconfig-json 0.1.0

package/index.js

@@ -0,0 +1,9 @@
+import { CompilerOptions, Jsx, Lib, Module, ModuleDetection, ModuleResolution, NewLine, Target } from "./CompilerOptions.js";
+import { PortableTsconfig } from "./PortableTsconfig.js";
+import { ResolvedTsconfig } from "./ResolvedTsconfig.js";
+import { TsconfigDiscovery } from "./TsconfigDiscovery.js";
+import { FallbackPolling, Reference, TsconfigJson, TsconfigJsonFromString, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions } from "./TsconfigJson.js";
+import { TsconfigExtendsError, TsconfigLoader } from "./TsconfigLoader.js";
+import { TsEnumCodec } from "./TsEnumCodec.js";
+
+export { CompilerOptions, FallbackPolling, Jsx, Lib, Module, ModuleDetection, ModuleResolution, NewLine, PortableTsconfig, Reference, ResolvedTsconfig, Target, TsEnumCodec, TsconfigDiscovery, TsconfigExtendsError, TsconfigJson, TsconfigJsonFromString, TsconfigLoader, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };

package/internal/extendsTarget.js

@@ -0,0 +1,234 @@
+import { Effect, FileSystem, Option, Path } from "effect";
+import { Walker } from "@effected/walker";
+import { Jsonc } from "@effected/jsonc";
+
+//#region src/internal/extendsTarget.ts
+/**
+* The `extends` target-resolution engine (E1 relative/rooted, E2 bare-specifier
+* node_modules lookup). Every input reaching {@link resolveExports} is an
+* untrusted `package.json` `exports` map, so every recursive surface carries a
+* depth guard, every untrusted map read goes through `Object.hasOwn`, dunder
+* keys are skipped, and substituted maps are built with `Object.create(null)` —
+* a JSON-parsed `{"__proto__": …}` key must never read or assign a prototype.
+*
+* A hostile `package.json` must never defect or fail the whole resolution: a
+* malformed manifest is absorbed to "no resolution for that candidate", and
+* only a genuine `PlatformError` from the underlying IO flows through the typed
+* error channel.
+*/
+/** Conditions honored in an `exports` condition object, plus the always-eligible `default`. */
+const CONDITIONS = /* @__PURE__ */ new Set([
+	"require",
+	"types",
+	"node"
+]);
+/** Keys that are never data on a plain object. Skipped on every untrusted read. */
+const DUNDER_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Depth guard for the recursive exports walk (condition nesting, fallback arrays, wildcard substitution). */
+const MAX_EXPORTS_DEPTH = 32;
+/** Split a bare specifier into its package name and its subpath ("" when the whole spec is the package). */
+const parseSpecifier = (spec) => {
+	if (spec.startsWith("@")) {
+		const parts = spec.split("/");
+		return {
+			pkg: parts.slice(0, 2).join("/"),
+			subpath: parts.slice(2).join("/")
+		};
+	}
+	const slash = spec.indexOf("/");
+	return slash === -1 ? {
+		pkg: spec,
+		subpath: ""
+	} : {
+		pkg: spec.slice(0, slash),
+		subpath: spec.slice(slash + 1)
+	};
+};
+/** Match a single-`*` subpath pattern against a subpath, returning the captured segment or `null`. */
+const matchWildcard = (pattern, subpath) => {
+	const star = pattern.indexOf("*");
+	if (star === -1 || pattern.indexOf("*", star + 1) !== -1) return null;
+	const prefix = pattern.slice(0, star);
+	const suffix = pattern.slice(star + 1);
+	if (subpath.length < prefix.length + suffix.length) return null;
+	if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) return null;
+	return subpath.slice(prefix.length, subpath.length - suffix.length);
+};
+/** Substitute a captured wildcard segment into an export value, hardened against dunder keys and unbounded nesting. */
+const substituteWildcard = (value, captured, depth) => {
+	if (depth > MAX_EXPORTS_DEPTH) return null;
+	if (typeof value === "string") return value.replace(/\*/g, captured);
+	if (Array.isArray(value)) return value.map((entry) => substituteWildcard(entry, captured, depth + 1));
+	if (typeof value === "object" && value !== null) {
+		const result = Object.create(null);
+		for (const key of Object.keys(value)) {
+			if (DUNDER_KEYS.has(key) || !Object.hasOwn(value, key)) continue;
+			result[key] = substituteWildcard(value[key], captured, depth + 1);
+		}
+		return result;
+	}
+	return value;
+};
+/** Find the export value for a subpath: exact key first, then a single-`*` pattern (substituted), else `undefined`. */
+const matchExportKey = (exports, subpath) => {
+	if (typeof exports === "string") return subpath === "." ? exports : void 0;
+	if (Array.isArray(exports)) return subpath === "." ? exports : void 0;
+	if (typeof exports !== "object" || exports === null) return void 0;
+	const obj = exports;
+	const keys = Object.keys(obj);
+	if (!(keys.length > 0 && keys.every((key) => key.startsWith(".")))) return subpath === "." ? obj : void 0;
+	if (!DUNDER_KEYS.has(subpath) && Object.hasOwn(obj, subpath)) return obj[subpath];
+	let best;
+	for (const pattern of keys) {
+		if (DUNDER_KEYS.has(pattern) || !pattern.includes("*") || !Object.hasOwn(obj, pattern)) continue;
+		const captured = matchWildcard(pattern, subpath);
+		if (captured === null) continue;
+		const prefixLength = pattern.indexOf("*");
+		if (best === void 0 || prefixLength > best.prefixLength) best = {
+			pattern,
+			captured,
+			prefixLength
+		};
+	}
+	return best === void 0 ? void 0 : substituteWildcard(obj[best.pattern], best.captured, 0);
+};
+/**
+* Resolve an export value to a `.json` string target: strings gate on the
+* `.json` suffix, fallback arrays yield the first resolvable entry, and
+* condition objects are matched in map insertion order (Node semantics) against
+* the honored conditions plus `default`, under the depth guard.
+*/
+const resolveConditionValue = (value, depth) => {
+	if (depth > MAX_EXPORTS_DEPTH) return void 0;
+	if (typeof value === "string") return value.endsWith(".json") ? value : void 0;
+	if (Array.isArray(value)) {
+		for (const entry of value) {
+			const resolved = resolveConditionValue(entry, depth + 1);
+			if (resolved !== void 0) return resolved;
+		}
+		return;
+	}
+	if (typeof value === "object" && value !== null) {
+		const obj = value;
+		for (const key of Object.keys(obj)) {
+			if (DUNDER_KEYS.has(key) || !Object.hasOwn(obj, key)) continue;
+			if (CONDITIONS.has(key) || key === "default") {
+				const resolved = resolveConditionValue(obj[key], depth + 1);
+				if (resolved !== void 0) return resolved;
+			}
+		}
+	}
+};
+/**
+* Resolve a `package.json` `exports` map for a subpath key (`"."` for the
+* package root, `"./sub"` for a subpath) to its `.json` target string. Pure and
+* hardened; exported for direct unit testing. The returned target is verbatim
+* from the manifest (still relative to the package directory) — the caller joins
+* and probes it.
+*/
+const resolveExports = (exports, subpath) => {
+	const matched = matchExportKey(exports, subpath);
+	if (matched === void 0) return Option.none();
+	const resolved = resolveConditionValue(matched, 0);
+	return resolved === void 0 ? Option.none() : Option.some(resolved);
+};
+/**
+* Read and parse a `package.json`, coercing every failure that is not a
+* genuine IO error to an EMPTY manifest — tsc's `readJson`
+* (typescript.js:21176, `readJsonOrUndefined(path, host) || {}`) does exactly
+* this, so a missing, unparseable or non-object manifest falls through to the
+* manifest-less lookups (no exports, no tsconfig field) rather than deciding
+* the candidate. A `PlatformError` from `exists` flows through.
+*/
+const readManifest = (fs, manifestPath) => Effect.gen(function* () {
+	if (!(yield* fs.exists(manifestPath))) return {};
+	const text = yield* fs.readFileString(manifestPath);
+	const parsed = yield* Effect.option(Jsonc.parse(text));
+	if (Option.isNone(parsed)) return {};
+	const value = parsed.value;
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+});
+/** Read an own property of an untrusted record, guarding dunder keys and inherited members. */
+const ownProp = (record, key) => !DUNDER_KEYS.has(key) && Object.hasOwn(record, key) ? record[key] : void 0;
+/**
+* Resolve E1 relative/rooted targets: the exact file wins verbatim (even
+* extensionless); otherwise, if the target does not already end in `.json`, the
+* `.json`-appended path is tried. There is no directory fallback.
+*/
+const resolveRelative = (fs, path, fromDir, spec) => Effect.gen(function* () {
+	const abs = path.resolve(fromDir, spec);
+	if (yield* fs.exists(abs)) return Option.some(abs);
+	if (!abs.endsWith(".json")) {
+		const withJson = `${abs}.json`;
+		if (yield* fs.exists(withJson)) return Option.some(withJson);
+	}
+	return Option.none();
+});
+/**
+* Probe one candidate package under an ancestor's `node_modules`. `none` means
+* "did not resolve here — keep walking": tsc's ancestor walk
+* (forEachAncestorDirectoryStoppingAtGlobalCache, typescript.js:46466) only
+* stops on a defined result, so a present-but-unresolved candidate does NOT
+* shadow a farther ancestor's copy. There is no `package.json` presence gate —
+* tsc probes `<pkg>/tsconfig.json` even when the manifest is absent
+* (loadNodeModuleFromDirectoryWorker, typescript.js:45943).
+*/
+const tryCandidate = (fs, path, dir, pkg, subpath) => Effect.gen(function* () {
+	const pkgDir = path.join(dir, "node_modules", pkg);
+	const record = yield* readManifest(fs, path.join(pkgDir, "package.json"));
+	const exports = ownProp(record, "exports");
+	if (exports !== void 0) {
+		const target = resolveExports(exports, subpath === "" ? "." : `./${subpath}`);
+		if (Option.isNone(target)) return Option.none();
+		const abs = path.resolve(pkgDir, target.value);
+		return (yield* fs.exists(abs)) ? Option.some(abs) : Option.none();
+	}
+	if (subpath !== "") {
+		const exact = path.resolve(pkgDir, subpath);
+		if (yield* fs.exists(exact)) return Option.some(exact);
+		if (!subpath.endsWith(".json")) {
+			const withJson = `${exact}.json`;
+			if (yield* fs.exists(withJson)) return Option.some(withJson);
+		}
+		return Option.none();
+	}
+	const tsField = ownProp(record, "tsconfig");
+	if (typeof tsField === "string" && tsField !== "") {
+		const abs = path.resolve(pkgDir, tsField);
+		if (yield* fs.exists(abs)) return Option.some(abs);
+	}
+	const fallback = path.join(pkgDir, "tsconfig.json");
+	return (yield* fs.exists(fallback)) ? Option.some(fallback) : Option.none();
+});
+/**
+* Resolve an `extends` target to an absolute config path. Relative and rooted
+* specifiers (E1) resolve against the extending config's directory; bare
+* specifiers (E2) walk up the ancestor `node_modules` chain, skipping ancestors
+* named `node_modules`, and resolve against the first package found.
+*
+* Absence is `Option.none()`; a malformed manifest is coerced to an empty one
+* (tsc parity — the candidate's manifest-less lookups still run); a
+* `PlatformError` from the underlying IO flows through.
+*/
+const resolveExtendsTarget = (spec, fromConfigPath) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const fromDir = path.dirname(fromConfigPath);
+	const normalized = spec.replace(/\\/g, "/");
+	if (normalized.startsWith("./") || normalized.startsWith("../") || path.isAbsolute(normalized)) return yield* resolveRelative(fs, path, fromDir, normalized);
+	const { pkg, subpath } = parseSpecifier(normalized);
+	const ancestors = yield* Walker.ascend(fromDir);
+	for (const dir of ancestors) {
+		if (path.basename(dir) === "node_modules") continue;
+		const candidate = yield* tryCandidate(fs, path, dir, pkg, subpath);
+		if (Option.isSome(candidate)) return candidate;
+	}
+	return Option.none();
+});
+
+//#endregion
+export { resolveExports, resolveExtendsTarget };

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@effected/tsconfig-json",
+	"version": "0.1.0",
+	"private": false,
+	"description": "Composable tsconfig.json handling for Effect: schemas, extends-chain resolution, and config discovery.",
+	"keywords": [
+		"tsconfig",
+		"typescript",
+		"config",
+		"extends",
+		"resolution",
+		"effect",
+		"schema",
+		"effected"
+	],
+	"homepage": "https://github.com/spencerbeggs/effected/tree/main/packages/tsconfig-json#readme",
+	"bugs": {
+		"url": "https://github.com/spencerbeggs/effected/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/spencerbeggs/effected.git",
+		"directory": "packages/tsconfig-json"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "C. Spencer Beggs",
+		"email": "spencer@beggs.codes",
+		"url": "https://spencerbeg.gs"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"import": "./index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"peerDependencies": {
+		"@effected/jsonc": "0.1.0",
+		"@effected/walker": "0.1.0",
+		"effect": "4.0.0-beta.98"
+	},
+	"engines": {
+		"node": ">=24.11.0"
+	}
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.9"
+    }
+  ]
+}