@ucdjs/release-scripts 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/eta-BV8TCRDW.mjs

@@ -0,0 +1,481 @@
+import * as fs from "node:fs";
+import * as path$2 from "node:path";
+
+//#region node_modules/.pnpm/eta@4.5.1/node_modules/eta/dist/index.mjs
+var EtaError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "Eta Error";
+	}
+};
+var EtaParseError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaParser Error";
+	}
+};
+var EtaRuntimeError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaRuntime Error";
+	}
+};
+var EtaFileResolutionError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaFileResolution Error";
+	}
+};
+var EtaNameResolutionError = class extends EtaError {
+	constructor(message) {
+		super(message);
+		this.name = "EtaNameResolution Error";
+	}
+};
+/**
+* Throws an EtaError with a nicely formatted error and message showing where in the template the error occurred.
+*/
+function ParseErr(message, str, indx) {
+	const whitespace = str.slice(0, indx).split(/\n/);
+	const lineNo = whitespace.length;
+	const colNo = whitespace[lineNo - 1].length + 1;
+	message += " at line " + lineNo + " col " + colNo + ":\n\n  " + str.split(/\n/)[lineNo - 1] + "\n  " + Array(colNo).join(" ") + "^";
+	throw new EtaParseError(message);
+}
+function RuntimeErr(originalError, str, lineNo, path$1) {
+	const lines = str.split("\n");
+	const start = Math.max(lineNo - 3, 0);
+	const end = Math.min(lines.length, lineNo + 3);
+	const filename = path$1;
+	const context = lines.slice(start, end).map((line, i) => {
+		const curr = i + start + 1;
+		return (curr === lineNo ? " >> " : "    ") + curr + "| " + line;
+	}).join("\n");
+	const err = new EtaRuntimeError((filename ? filename + ":" + lineNo + "\n" : "line " + lineNo + "\n") + context + "\n\n" + originalError.message);
+	err.name = originalError.name;
+	err.cause = originalError;
+	throw err;
+}
+function readFile(path$1) {
+	let res = "";
+	try {
+		res = fs.readFileSync(path$1, "utf8");
+	} catch (err) {
+		if (err?.code === "ENOENT") throw new EtaFileResolutionError(`Could not find template: ${path$1}`);
+		else throw err;
+	}
+	return res;
+}
+function resolvePath(templatePath, options) {
+	let resolvedFilePath = "";
+	const views = this.config.views;
+	if (!views) throw new EtaFileResolutionError("Views directory is not defined");
+	const baseFilePath = options?.filepath;
+	const defaultExtension = this.config.defaultExtension === void 0 ? ".eta" : this.config.defaultExtension;
+	const cacheIndex = JSON.stringify({
+		filename: baseFilePath,
+		path: templatePath,
+		views: this.config.views
+	});
+	templatePath += path$2.extname(templatePath) ? "" : defaultExtension;
+	if (baseFilePath) {
+		if (this.config.cacheFilepaths && this.filepathCache[cacheIndex]) return this.filepathCache[cacheIndex];
+		if (absolutePathRegExp.exec(templatePath)?.length) {
+			const formattedPath = templatePath.replace(/^\/*|^\\*/, "");
+			resolvedFilePath = path$2.join(views, formattedPath);
+		} else resolvedFilePath = path$2.join(path$2.dirname(baseFilePath), templatePath);
+	} else resolvedFilePath = path$2.join(views, templatePath);
+	if (dirIsChild(views, resolvedFilePath)) {
+		if (baseFilePath && this.config.cacheFilepaths) this.filepathCache[cacheIndex] = resolvedFilePath;
+		return resolvedFilePath;
+	} else throw new EtaFileResolutionError(`Template '${templatePath}' is not in the views directory`);
+}
+function dirIsChild(parent, dir) {
+	const relative = path$2.relative(parent, dir);
+	return relative && !relative.startsWith("..") && !path$2.isAbsolute(relative);
+}
+const absolutePathRegExp = /^\\|^\//;
+/* istanbul ignore next */
+const AsyncFunction = (async () => {}).constructor;
+/**
+* Takes a template string and returns a template function that can be called with (data, config)
+*
+* @param str - The template string
+* @param config - A custom configuration object (optional)
+*/
+function compile(str, options) {
+	const config = this.config;
+	const ctor = options?.async ? AsyncFunction : Function;
+	try {
+		return new ctor(config.varName, "options", this.compileToString.call(this, str, options));
+	} catch (e) {
+		if (e instanceof SyntaxError) throw new EtaParseError("Bad template syntax\n\n" + e.message + "\n" + Array(e.message.length + 1).join("=") + "\n" + this.compileToString.call(this, str, options) + "\n");
+		else throw e;
+	}
+}
+/**
+* Compiles a template string to a function string. Most often users just use `compile()`, which calls `compileToString` and creates a new function using the result
+*/
+function compileToString(str, options) {
+	const config = this.config;
+	const isAsync = options?.async;
+	const compileBody$1 = this.compileBody;
+	const buffer = this.parse.call(this, str);
+	let res = `${config.functionHeader}
+let include = (__eta_t, __eta_d) => this.render(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+let includeAsync = (__eta_t, __eta_d) => this.renderAsync(__eta_t, {...${config.varName}, ...(__eta_d ?? {})}, options);
+
+let __eta = {res: "", e: this.config.escapeFunction, f: this.config.filterFunction${config.debug ? ", line: 1, templateStr: \"" + str.replace(/\\|"/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n") + "\"" : ""}};
+
+function layout(path, data) {
+  __eta.layout = path;
+  __eta.layoutData = data;
+}${config.debug ? "try {" : ""}${config.useWith ? "with(" + config.varName + "||{}){" : ""}
+
+function ${config.outputFunctionName}(s){__eta.res+=s;}
+
+${compileBody$1.call(this, buffer)}
+if (__eta.layout) {
+  __eta.res = ${isAsync ? "await includeAsync" : "include"} (__eta.layout, {...${config.varName}, body: __eta.res, ...__eta.layoutData});
+}
+${config.useWith ? "}" : ""}${config.debug ? "} catch (e) { this.RuntimeErr(e, __eta.templateStr, __eta.line, options.filepath) }" : ""}
+return __eta.res;
+`;
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processFnString) res = plugin.processFnString(res, config);
+	}
+	return res;
+}
+/**
+* Loops through the AST generated by `parse` and transform each item into JS calls
+*
+* **Example**
+*
+* ```js
+* let templateAST = ['Hi ', { val: 'it.name', t: 'i' }]
+* compileBody.call(Eta, templateAST)
+* // => "__eta.res+='Hi '\n__eta.res+=__eta.e(it.name)\n"
+* ```
+*/
+function compileBody(buff) {
+	const config = this.config;
+	let i = 0;
+	const buffLength = buff.length;
+	let returnStr = "";
+	for (; i < buffLength; i++) {
+		const currentBlock = buff[i];
+		if (typeof currentBlock === "string") returnStr += "__eta.res+='" + currentBlock + "';\n";
+		else {
+			const type = currentBlock.t;
+			let content = currentBlock.val || "";
+			if (config.debug) returnStr += "__eta.line=" + currentBlock.lineNo + "\n";
+			if (type === "r") {
+				if (config.autoFilter) content = "__eta.f(" + content + ")";
+				returnStr += "__eta.res+=" + content + ";\n";
+			} else if (type === "i") {
+				if (config.autoFilter) content = "__eta.f(" + content + ")";
+				if (config.autoEscape) content = "__eta.e(" + content + ")";
+				returnStr += "__eta.res+=" + content + ";\n";
+			} else if (type === "e") returnStr += content + "\n";
+		}
+	}
+	return returnStr;
+}
+/**
+* Takes a string within a template and trims it, based on the preceding tag's whitespace control and `config.autoTrim`
+*/
+function trimWS(str, config, wsLeft, wsRight) {
+	let leftTrim;
+	let rightTrim;
+	if (Array.isArray(config.autoTrim)) {
+		leftTrim = config.autoTrim[1];
+		rightTrim = config.autoTrim[0];
+	} else leftTrim = rightTrim = config.autoTrim;
+	if (wsLeft || wsLeft === false) leftTrim = wsLeft;
+	if (wsRight || wsRight === false) rightTrim = wsRight;
+	if (!rightTrim && !leftTrim) return str;
+	if (leftTrim === "slurp" && rightTrim === "slurp") return str.trim();
+	if (leftTrim === "_" || leftTrim === "slurp") str = str.trimStart();
+	else if (leftTrim === "-" || leftTrim === "nl") str = str.replace(/^(?:\r\n|\n|\r)/, "");
+	if (rightTrim === "_" || rightTrim === "slurp") str = str.trimEnd();
+	else if (rightTrim === "-" || rightTrim === "nl") str = str.replace(/(?:\r\n|\n|\r)$/, "");
+	return str;
+}
+/**
+* A map of special HTML characters to their XML-escaped equivalents
+*/
+const escMap = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function replaceChar(s) {
+	return escMap[s];
+}
+/**
+* XML-escapes an input value after converting it to a string
+*
+* @param str - Input value (usually a string)
+* @returns XML-escaped string
+*/
+function XMLEscape(str) {
+	const newStr = String(str);
+	if (/[&<>"']/.test(newStr)) return newStr.replace(/[&<>"']/g, replaceChar);
+	else return newStr;
+}
+/** Eta's base (global) configuration */
+const defaultConfig = {
+	autoEscape: true,
+	autoFilter: false,
+	autoTrim: [false, "nl"],
+	cache: false,
+	cacheFilepaths: true,
+	debug: false,
+	escapeFunction: XMLEscape,
+	filterFunction: (val) => String(val),
+	outputFunctionName: "output",
+	functionHeader: "",
+	parse: {
+		exec: "",
+		interpolate: "=",
+		raw: "~"
+	},
+	plugins: [],
+	rmWhitespace: false,
+	tags: ["<%", "%>"],
+	useWith: false,
+	varName: "it",
+	defaultExtension: ".eta"
+};
+const templateLitReg = /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})*}|(?!\${)[^\\`])*`/g;
+const singleQuoteReg = /'(?:\\[\s\w"'\\`]|[^\n\r'\\])*?'/g;
+const doubleQuoteReg = /"(?:\\[\s\w"'\\`]|[^\n\r"\\])*?"/g;
+/** Escape special regular expression characters inside a string */
+function escapeRegExp(string) {
+	return string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+}
+function getLineNo(str, index) {
+	return str.slice(0, index).split("\n").length;
+}
+function parse(str) {
+	const config = this.config;
+	let buffer = [];
+	let trimLeftOfNextStr = false;
+	let lastIndex = 0;
+	const parseOptions = config.parse;
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processTemplate) str = plugin.processTemplate(str, config);
+	}
+	if (config.rmWhitespace) str = str.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+	templateLitReg.lastIndex = 0;
+	singleQuoteReg.lastIndex = 0;
+	doubleQuoteReg.lastIndex = 0;
+	function pushString(strng, shouldTrimRightOfString) {
+		if (strng) {
+			strng = trimWS(strng, config, trimLeftOfNextStr, shouldTrimRightOfString);
+			if (strng) {
+				strng = strng.replace(/\\|'/g, "\\$&").replace(/\r\n|\n|\r/g, "\\n");
+				buffer.push(strng);
+			}
+		}
+	}
+	const prefixes = [
+		parseOptions.exec,
+		parseOptions.interpolate,
+		parseOptions.raw
+	].reduce((accumulator, prefix) => {
+		if (accumulator && prefix) return accumulator + "|" + escapeRegExp(prefix);
+		else if (prefix) return escapeRegExp(prefix);
+		else return accumulator;
+	}, "");
+	const parseOpenReg = new RegExp(escapeRegExp(config.tags[0]) + "(-|_)?\\s*(" + prefixes + ")?\\s*", "g");
+	const parseCloseReg = new RegExp("'|\"|`|\\/\\*|(\\s*(-|_)?" + escapeRegExp(config.tags[1]) + ")", "g");
+	let m;
+	while (m = parseOpenReg.exec(str)) {
+		const precedingString = str.slice(lastIndex, m.index);
+		lastIndex = m[0].length + m.index;
+		const wsLeft = m[1];
+		const prefix = m[2] || "";
+		pushString(precedingString, wsLeft);
+		parseCloseReg.lastIndex = lastIndex;
+		let closeTag;
+		let currentObj = false;
+		while (closeTag = parseCloseReg.exec(str)) if (closeTag[1]) {
+			const content = str.slice(lastIndex, closeTag.index);
+			parseOpenReg.lastIndex = lastIndex = parseCloseReg.lastIndex;
+			trimLeftOfNextStr = closeTag[2];
+			currentObj = {
+				t: prefix === parseOptions.exec ? "e" : prefix === parseOptions.raw ? "r" : prefix === parseOptions.interpolate ? "i" : "",
+				val: content
+			};
+			break;
+		} else {
+			const char = closeTag[0];
+			if (char === "/*") {
+				const commentCloseInd = str.indexOf("*/", parseCloseReg.lastIndex);
+				if (commentCloseInd === -1) ParseErr("unclosed comment", str, closeTag.index);
+				parseCloseReg.lastIndex = commentCloseInd;
+			} else if (char === "'") {
+				singleQuoteReg.lastIndex = closeTag.index;
+				if (singleQuoteReg.exec(str)) parseCloseReg.lastIndex = singleQuoteReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			} else if (char === "\"") {
+				doubleQuoteReg.lastIndex = closeTag.index;
+				if (doubleQuoteReg.exec(str)) parseCloseReg.lastIndex = doubleQuoteReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			} else if (char === "`") {
+				templateLitReg.lastIndex = closeTag.index;
+				if (templateLitReg.exec(str)) parseCloseReg.lastIndex = templateLitReg.lastIndex;
+				else ParseErr("unclosed string", str, closeTag.index);
+			}
+		}
+		if (currentObj) {
+			if (config.debug) currentObj.lineNo = getLineNo(str, m.index);
+			buffer.push(currentObj);
+		} else ParseErr("unclosed tag", str, m.index);
+	}
+	pushString(str.slice(lastIndex, str.length), false);
+	if (config.plugins) for (let i = 0; i < config.plugins.length; i++) {
+		const plugin = config.plugins[i];
+		if (plugin.processAST) buffer = plugin.processAST(buffer, config);
+	}
+	return buffer;
+}
+function handleCache(template, options) {
+	const templateStore = options?.async ? this.templatesAsync : this.templatesSync;
+	if (this.resolvePath && this.readFile && !template.startsWith("@")) {
+		const templatePath = options.filepath;
+		const cachedTemplate = templateStore.get(templatePath);
+		if (this.config.cache && cachedTemplate) return cachedTemplate;
+		else {
+			const templateString = this.readFile(templatePath);
+			const templateFn = this.compile(templateString, options);
+			if (this.config.cache) templateStore.define(templatePath, templateFn);
+			return templateFn;
+		}
+	} else {
+		const cachedTemplate = templateStore.get(template);
+		if (cachedTemplate) return cachedTemplate;
+		else throw new EtaNameResolutionError(`Failed to get template '${template}'`);
+	}
+}
+function render(template, data, meta) {
+	let templateFn;
+	const options = {
+		...meta,
+		async: false
+	};
+	if (typeof template === "string") {
+		if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+		templateFn = handleCache.call(this, template, options);
+	} else templateFn = template;
+	return templateFn.call(this, data, options);
+}
+function renderAsync(template, data, meta) {
+	let templateFn;
+	const options = {
+		...meta,
+		async: true
+	};
+	if (typeof template === "string") {
+		if (this.resolvePath && this.readFile && !template.startsWith("@")) options.filepath = this.resolvePath(template, options);
+		templateFn = handleCache.call(this, template, options);
+	} else templateFn = template;
+	const res = templateFn.call(this, data, options);
+	return Promise.resolve(res);
+}
+function renderString(template, data) {
+	const templateFn = this.compile(template, { async: false });
+	return render.call(this, templateFn, data);
+}
+function renderStringAsync(template, data) {
+	const templateFn = this.compile(template, { async: true });
+	return renderAsync.call(this, templateFn, data);
+}
+/**
+* Handles storage and accessing of values
+*
+* In this case, we use it to store compiled template functions
+* Indexed by their `name` or `filename`
+*/
+var Cacher = class {
+	constructor(cache) {
+		this.cache = cache;
+	}
+	define(key, val) {
+		this.cache[key] = val;
+	}
+	get(key) {
+		return this.cache[key];
+	}
+	remove(key) {
+		delete this.cache[key];
+	}
+	reset() {
+		this.cache = {};
+	}
+	load(cacheObj) {
+		this.cache = {
+			...this.cache,
+			...cacheObj
+		};
+	}
+};
+var Eta$1 = class {
+	constructor(customConfig) {
+		if (customConfig) this.config = {
+			...defaultConfig,
+			...customConfig
+		};
+		else this.config = { ...defaultConfig };
+	}
+	config;
+	RuntimeErr = RuntimeErr;
+	compile = compile;
+	compileToString = compileToString;
+	compileBody = compileBody;
+	parse = parse;
+	render = render;
+	renderAsync = renderAsync;
+	renderString = renderString;
+	renderStringAsync = renderStringAsync;
+	filepathCache = {};
+	templatesSync = new Cacher({});
+	templatesAsync = new Cacher({});
+	resolvePath = null;
+	readFile = null;
+	configure(customConfig) {
+		this.config = {
+			...this.config,
+			...customConfig
+		};
+	}
+	withConfig(customConfig) {
+		return {
+			...this,
+			config: {
+				...this.config,
+				...customConfig
+			}
+		};
+	}
+	loadTemplate(name, template, options) {
+		if (typeof template === "string") (options?.async ? this.templatesAsync : this.templatesSync).define(name, this.compile(template, options));
+		else {
+			let templates = this.templatesSync;
+			if (template.constructor.name === "AsyncFunction" || options?.async) templates = this.templatesAsync;
+			templates.define(name, template);
+		}
+	}
+};
+var Eta = class extends Eta$1 {
+	readFile = readFile;
+	resolvePath = resolvePath;
+};
+
+//#endregion
+export { Eta as t };

package/dist/index.d.mts

@@ -1,125 +1,70 @@
-//#region src/types.d.ts
-type BumpKind = "none" | "patch" | "minor" | "major";
-interface PackageJson {
-  name: string;
-  version: string;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  [key: string]: unknown;
-}
-interface WorkspacePackage {
-  name: string;
-  version: string;
-  path: string;
-  packageJson: PackageJson;
-  workspaceDependencies: string[];
-  workspaceDevDependencies: string[];
-}
+import { Context, Effect, Schema } from "effect";
+import { CommandExecutor } from "@effect/platform";
+
+//#region src/options.d.ts
 interface FindWorkspacePackagesOptions {
-  /**
-   * Package names to exclude
-   */
-  excluded?: string[];
-  /**
-   * Only include these packages (if specified, all others are excluded)
-   */
-  included?: string[];
-  /**
-   * Whether to exclude private packages (default: false)
-   */
+  exclude?: string[];
+  include?: string[];
   excludePrivate?: boolean;
 }
-interface VersionUpdate {
-  /**
-   * The package being updated
-   */
-  package: WorkspacePackage;
-  /**
-   * Current version
-   */
-  currentVersion: string;
-  /**
-   * New version to release
-   */
-  newVersion: string;
-  /**
-   * Type of version bump
-   */
-  bumpType: BumpKind;
-  /**
-   * Whether this package has direct changes (vs being updated due to dependency changes)
-   */
-  hasDirectChanges: boolean;
-}
-interface ReleaseOptions {
-  /**
-   * Repository identifier (e.g., "owner/repo")
-   */
-  repo: string;
-  /**
-   * Root directory of the workspace (defaults to process.cwd())
-   */
+interface ReleaseScriptsOptionsInput {
+  dryRun?: boolean;
+  repo: `${string}/${string}`;
   workspaceRoot?: string;
-  /**
-   * Specific packages to prepare for release.
-   * - true: discover all packages
-   * - FindWorkspacePackagesOptions: discover with filters
-   * - string[]: specific package names
-   */
   packages?: true | FindWorkspacePackagesOptions | string[];
-  /**
-   * Branch name for the release PR (defaults to "release/next")
-   */
-  releaseBranch?: string;
-  /**
-   * Interactive prompt configuration
-   */
-  prompts?: {
-    /**
-     * Enable package selection prompt (defaults to true when not in CI)
-     */
-    packages?: boolean;
-    /**
-     * Enable version override prompt (defaults to true when not in CI)
-     */
-    versions?: boolean;
-  };
-  /**
-   * Whether to perform a dry run (no changes pushed or PR created)
-   * @default false
-   */
-  dryRun?: boolean;
-  /**
-   * Whether to enable safety safeguards (e.g., checking for clean working directory)
-   * @default true
-   */
-  safeguards?: boolean;
-  /**
-   * GitHub token for authentication
-   */
   githubToken: string;
+  branch?: {
+    release?: string;
+    default?: string;
+  };
+  globalCommitMode?: "dependencies" | "all" | "none";
   pullRequest?: {
+    title?: string;
+    body?: string;
+  };
+  types?: Record<string, {
     title: string;
-    body: string;
+    color?: string;
+  }>;
+  changelog?: {
+    enabled?: boolean;
+    template?: string;
+    emojis?: boolean;
+  };
+  npm?: {
+    otp?: string;
+    provenance?: boolean;
   };
-}
-interface ReleaseResult {
-  /**
-   * Packages that will be updated
-   */
-  updates: VersionUpdate[];
-  /**
-   * URL of the created or updated PR
-   */
-  prUrl?: string;
-  /**
-   * Whether a new PR was created (vs updating existing)
-   */
-  created: boolean;
 }
 //#endregion
-//#region src/release.d.ts
-declare function release(options: ReleaseOptions): Promise<ReleaseResult | null>;
+//#region src/services/workspace.service.d.ts
+declare const WorkspacePackageSchema: Schema.Struct<{
+  name: typeof Schema.String;
+  version: typeof Schema.String;
+  path: typeof Schema.String;
+  packageJson: Schema.Struct<{
+    name: typeof Schema.String;
+    private: Schema.optional<typeof Schema.Boolean>;
+    version: Schema.optional<typeof Schema.String>;
+    dependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    devDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    peerDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+  }>;
+  workspaceDependencies: Schema.Array$<typeof Schema.String>;
+  workspaceDevDependencies: Schema.Array$<typeof Schema.String>;
+}>;
+type WorkspacePackage = Schema.Schema.Type<typeof WorkspacePackageSchema>;
+//#endregion
+//#region src/index.d.ts
+interface ReleaseScripts {
+  verify: () => Promise<void>;
+  prepare: () => Promise<void>;
+  publish: () => Promise<void>;
+  packages: {
+    list: () => Promise<readonly WorkspacePackage[]>;
+    get: (packageName: string) => Promise<WorkspacePackage | null>;
+  };
+}
+declare function createReleaseScripts(options: ReleaseScriptsOptionsInput): Promise<ReleaseScripts>;
 //#endregion
-export { release };
+export { ReleaseScripts, createReleaseScripts };