@codefast/cli 0.3.13-canary.3 → 0.3.13-canary.4

package/dist/lib/tag/infra/tag-since-writer.adapter.mjs

@@ -0,0 +1,343 @@
+import { applyEditsDescending, indentOfLineContaining } from "../../shared/source-code/domain/text-edit.model.mjs";
+import { injectable } from "@codefast/di";
+import ts from "typescript";
+//#region src/lib/tag/infra/tag-since-writer.adapter.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+const VERSION_TAG = "@since";
+function hasExportModifier(node) {
+	return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isTaggableDeclaration(node) {
+	return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+}
+function addDeclarationName(registry, name, declaration) {
+	if (!registry.has(name)) {
+		registry.set(name, new Set([declaration]));
+		return;
+	}
+	const bucket = registry.get(name);
+	if (bucket === void 0) throw new Error(`declaration registry missing set for ${name}`);
+	bucket.add(declaration);
+}
+function collectLocalNamedDeclarations(sf) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const statement of sf.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isClassDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isInterfaceDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isTypeAliasDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isEnumDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) addDeclarationName(declarations, declaration.name.text, statement);
+	}
+	return declarations;
+}
+function collectExportedDeclarations(sf) {
+	const exported = /* @__PURE__ */ new Set();
+	const localNamed = collectLocalNamedDeclarations(sf);
+	for (const statement of sf.statements) {
+		if (isTaggableDeclaration(statement) && hasExportModifier(statement)) {
+			exported.add(statement);
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				const localName = element.propertyName?.text ?? element.name.text;
+				const declarations = localNamed.get(localName);
+				if (!declarations) continue;
+				for (const declaration of declarations) exported.add(declaration);
+			}
+			continue;
+		}
+		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
+		const declarations = localNamed.get(statement.expression.text);
+		if (!declarations) continue;
+		for (const declaration of declarations) exported.add(declaration);
+	}
+	return exported;
+}
+function makeJSDocSinceLine(existingComment, sourceText, version) {
+	const commentText = sourceText.slice(existingComment.pos, existingComment.end);
+	const baseIndent = indentOfLineContaining(sourceText, existingComment.pos);
+	const normalizedBodyLines = commentText.replace(/^\/\*\*\s?/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "").replace(/\s+$/, "")).filter((line, lineIndex, lines) => {
+		if (line.length > 0) return true;
+		const hasNonEmptyBefore = lines.slice(0, lineIndex).some((value) => value.length > 0);
+		const hasNonEmptyAfter = lines.slice(lineIndex + 1).some((value) => value.length > 0);
+		return hasNonEmptyBefore && hasNonEmptyAfter;
+	});
+	const replacement = `/**\n${normalizedBodyLines.length > 0 ? `${normalizedBodyLines.map((line) => `${baseIndent} * ${line}`).join("\n")}\n${baseIndent} *\n` : ""}${baseIndent} * ${VERSION_TAG} ${version}\n${baseIndent} */`;
+	return {
+		start: existingComment.pos,
+		end: existingComment.end,
+		replacement
+	};
+}
+function makeSinceOnlyJSDocBlock(declarationIndent, version) {
+	return `/**\n${declarationIndent} * ${VERSION_TAG} ${version}\n${declarationIndent} */`;
+}
+function makeDeclarationSinceLine(declaration, sf, sourceText, version) {
+	if (ts.getJSDocTags(declaration).some((tag) => tag.tagName.text === "since")) return;
+	const lastJsDoc = ts.getJSDocCommentsAndTags(declaration).filter(ts.isJSDoc).at(-1);
+	if (lastJsDoc) return makeJSDocSinceLine(lastJsDoc, sourceText, version);
+	const start = declaration.getStart(sf);
+	const indent = indentOfLineContaining(sourceText, start);
+	return {
+		start,
+		end: start,
+		replacement: `${indent}${makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`
+	};
+}
+_dec = injectable([]);
+let _TagSinceWriterAdapter;
+(class {
+	static {
+		({c: [_TagSinceWriterAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	applySinceTagsToFile(filePath, version, fs, write) {
+		const sourceText = fs.readFileSync(filePath, "utf8");
+		const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+		const edits = [];
+		for (const declaration of collectExportedDeclarations(sf)) {
+			const edit = makeDeclarationSinceLine(declaration, sf, sourceText, version);
+			if (edit) edits.push(edit);
+		}
+		if (edits.length > 0 && write) {
+			const updated = applyEditsDescending(sourceText, edits);
+			fs.writeFileSync(filePath, updated, "utf8");
+		}
+		return {
+			filePath,
+			taggedDeclarations: edits.length,
+			changed: edits.length > 0
+		};
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _TagSinceWriterAdapter as TagSinceWriterAdapter };

package/dist/lib/tag/infra/tag-sync-cli-options.adapter.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/infra/tag-target-candidates.adapter.mjs

@@ -0,0 +1,170 @@
+import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
+import { globSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import picomatch from "picomatch";
+import { parse } from "yaml";
+//#region src/lib/tag/infra/tag-target-candidates.adapter.ts
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+const PACKAGE_JSON_FILE = "package.json";
+const DEFAULT_WORKSPACE_PACKAGE_PATTERNS = ["packages/*"];
+const pnpmWorkspaceSchema = z.object({ packages: z.array(z.string()).optional() }).passthrough();
+const packageNameSchema = z.object({ name: z.string().min(1).optional() }).passthrough();
+function toPosix(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function workspacePatternToPackageJsonGlob(pattern) {
+	const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+	if (!normalizedPattern) return `**/${PACKAGE_JSON_FILE}`;
+	return `${normalizedPattern}/${PACKAGE_JSON_FILE}`;
+}
+function splitWorkspacePackagePatterns(rawPatterns) {
+	const include = [];
+	const exclude = [];
+	for (const rawPattern of rawPatterns) {
+		const trimmedPattern = rawPattern.trim();
+		if (!trimmedPattern) continue;
+		if (trimmedPattern.startsWith("!")) {
+			exclude.push(trimmedPattern.slice(1).trim());
+			continue;
+		}
+		include.push(trimmedPattern);
+	}
+	return {
+		include,
+		exclude
+	};
+}
+async function readWorkspacePackagePatterns(rootDir, fs) {
+	const workspaceYamlPath = path.join(rootDir, PNPM_WORKSPACE_FILE);
+	if (!fs.existsSync(workspaceYamlPath)) return {
+		patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+		hasWorkspaceFile: false,
+		declaredEmptyPackages: false
+	};
+	let workspaceYamlRaw = "";
+	try {
+		workspaceYamlRaw = await fs.readFile(workspaceYamlPath, "utf8");
+	} catch (caughtReadError) {
+		throw new Error(`Failed to read ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtReadError)}`);
+	}
+	let parsedWorkspaceDoc;
+	try {
+		parsedWorkspaceDoc = parse(workspaceYamlRaw);
+	} catch (caughtParseError) {
+		throw new Error(`Failed to parse ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtParseError)}`);
+	}
+	const parsedWorkspaceResult = pnpmWorkspaceSchema.safeParse(parsedWorkspaceDoc);
+	if (!parsedWorkspaceResult.success) {
+		const issuePath = parsedWorkspaceResult.error.issues[0]?.path.join(".") ?? "<root>";
+		const issueMessage = parsedWorkspaceResult.error.issues[0]?.message ?? "Invalid value";
+		throw new Error(`Invalid ${PNPM_WORKSPACE_FILE} schema at "${issuePath}": ${issueMessage}`);
+	}
+	const hasPackagesKey = typeof parsedWorkspaceDoc === "object" && parsedWorkspaceDoc !== null && Object.prototype.hasOwnProperty.call(parsedWorkspaceDoc, "packages");
+	const workspacePackages = parsedWorkspaceResult.data.packages;
+	if (!workspacePackages) return {
+		patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: false
+	};
+	if (workspacePackages.length === 0 && hasPackagesKey) return {
+		patterns: [],
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: true
+	};
+	return {
+		patterns: workspacePackages,
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: false
+	};
+}
+async function discoverWorkspacePackageDirs(rootDir, fs) {
+	const workspacePackages = await readWorkspacePackagePatterns(rootDir, fs);
+	const { include, exclude } = splitWorkspacePackagePatterns(workspacePackages.patterns);
+	const includePatterns = include.length > 0 ? include : [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS];
+	const foundPackageDirs = /* @__PURE__ */ new Set();
+	const globOptions = {
+		cwd: rootDir,
+		posix: true,
+		...path.sep === "\\" ? { windowsPathsNoEscape: true } : {}
+	};
+	for (const pattern of includePatterns) {
+		const matches = globSync(workspacePatternToPackageJsonGlob(pattern), globOptions);
+		for (const matchedPath of matches) {
+			if (!matchedPath.endsWith(`/${PACKAGE_JSON_FILE}`)) continue;
+			const packageRelDir = matchedPath.slice(0, -`/${PACKAGE_JSON_FILE}`.length);
+			if (!packageRelDir) continue;
+			foundPackageDirs.add(path.resolve(rootDir, packageRelDir));
+		}
+	}
+	if (exclude.length === 0) return {
+		packageDirs: [...foundPackageDirs].sort((leftDir, rightDir) => leftDir.localeCompare(rightDir)),
+		hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+		declaredEmptyPackages: workspacePackages.declaredEmptyPackages
+	};
+	const excludeMatchers = exclude.map((excludePattern) => picomatch(excludePattern, { dot: true }));
+	const discoveredDirs = [...foundPackageDirs].filter((packageDir) => {
+		const relativePackagePath = toPosix(path.relative(rootDir, packageDir));
+		return !excludeMatchers.some((excludeMatcher) => excludeMatcher(relativePackagePath));
+	});
+	discoveredDirs.sort((leftDir, rightDir) => leftDir.localeCompare(rightDir));
+	return {
+		packageDirs: discoveredDirs,
+		hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+		declaredEmptyPackages: workspacePackages.declaredEmptyPackages
+	};
+}
+function readPackageName(packageDir, fs) {
+	const packageJsonPath = path.join(packageDir, PACKAGE_JSON_FILE);
+	if (!fs.existsSync(packageJsonPath)) return null;
+	try {
+		const rawPackageJson = fs.readFileSync(packageJsonPath, "utf8");
+		const parsedPackageJson = JSON.parse(rawPackageJson);
+		const parsedPackageName = packageNameSchema.safeParse(parsedPackageJson);
+		if (!parsedPackageName.success) return null;
+		return parsedPackageName.data.name ?? null;
+	} catch {
+		return null;
+	}
+}
+function toRootRelativePath(rootDir, absolutePath) {
+	const relativePath = path.relative(rootDir, absolutePath);
+	return relativePath ? toPosix(relativePath) : ".";
+}
+function toPackageTargetCandidate(rootDir, packageDir, fs) {
+	const packageName = readPackageName(packageDir, fs);
+	return {
+		candidatePath: packageDir,
+		rootRelativeCandidatePath: toRootRelativePath(rootDir, packageDir),
+		source: "workspace-package",
+		packageDir,
+		packageName
+	};
+}
+async function resolveTagTargetCandidates(rootDir, explicitTarget, fs) {
+	if (explicitTarget) {
+		const resolvedExplicitTarget = path.resolve(explicitTarget);
+		return [{
+			candidatePath: resolvedExplicitTarget,
+			rootRelativeCandidatePath: toRootRelativePath(rootDir, resolvedExplicitTarget),
+			source: "explicit-target",
+			packageDir: null,
+			packageName: null
+		}];
+	}
+	const workspaceDiscovery = await discoverWorkspacePackageDirs(rootDir, fs);
+	if (workspaceDiscovery.packageDirs.length === 0) {
+		if (workspaceDiscovery.hasWorkspaceFile) return [];
+		const repoSourceDir = path.join(rootDir, "src");
+		return [{
+			candidatePath: repoSourceDir,
+			rootRelativeCandidatePath: toRootRelativePath(rootDir, repoSourceDir),
+			source: "repo-src-fallback",
+			packageDir: null,
+			packageName: null
+		}];
+	}
+	return workspaceDiscovery.packageDirs.map((packageDir) => toPackageTargetCandidate(rootDir, packageDir, fs));
+}
+//#endregion
+export { resolveTagTargetCandidates };