@bryanchu10/create-template-ts 1.0.2 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bryan Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+[English](./README.md) · [繁體中文](./README.zh-TW.md)
+
+# create-template-ts
+
+[![npm version](https://img.shields.io/npm/v/@bryanchu10/create-template-ts)](https://www.npmjs.com/package/@bryanchu10/create-template-ts)
+[![npm downloads](https://img.shields.io/npm/dm/@bryanchu10/create-template-ts)](https://www.npmjs.com/package/@bryanchu10/create-template-ts)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+[![node](https://img.shields.io/badge/node-%3E%3D22-brightgreen?logo=node.js&logoColor=white)](https://nodejs.org)
+[![pnpm](https://img.shields.io/badge/pnpm-%3E%3D9-F69220?logo=pnpm&logoColor=white)](https://pnpm.io)
+
+Scaffold a modular TypeScript project for scripts and tooling.
+
+## Usage
+
+**pnpm**
+```bash
+pnpm create @bryanchu10/template-ts
+```
+
+**npm**
+```bash
+npx @bryanchu10/create-template-ts
+```
+
+Follow the prompts to choose a project name and template. The CLI will fetch the latest package versions automatically.
+
+## Templates
+
+| Template | Description |
+|----------|-------------|
+| `ts-script` | TypeScript script/tooling with neverthrow, ts-pattern, eslint, tsx, and rolldown |
+
+## Development
+
+```bash
+pnpm install
+pnpm dev       # watch mode
+pnpm build     # bundle with rolldown
+pnpm check     # type check
+pnpm lint      # eslint
+```
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for release history.
+
+## License
+
+[MIT](./LICENSE) © Bryan Chu

package/README.zh-TW.md

@@ -0,0 +1,49 @@
+[English](./README.md) · [繁體中文](./README.zh-TW.md)
+
+# create-template-ts
+
+[![npm version](https://img.shields.io/npm/v/@bryanchu10/create-template-ts)](https://www.npmjs.com/package/@bryanchu10/create-template-ts)
+[![npm downloads](https://img.shields.io/npm/dm/@bryanchu10/create-template-ts)](https://www.npmjs.com/package/@bryanchu10/create-template-ts)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+[![node](https://img.shields.io/badge/node-%3E%3D22-brightgreen?logo=node.js&logoColor=white)](https://nodejs.org)
+[![pnpm](https://img.shields.io/badge/pnpm-%3E%3D9-F69220?logo=pnpm&logoColor=white)](https://pnpm.io)
+
+快速建立模組化的 TypeScript 專案，適合腳本與工具開發。
+
+## 使用方式
+
+**pnpm**
+```bash
+pnpm create @bryanchu10/template-ts
+```
+
+**npm**
+```bash
+npx @bryanchu10/create-template-ts
+```
+
+依照提示選擇專案名稱與範本，CLI 會自動抓取最新的套件版本。
+
+## 範本
+
+| 範本 | 說明 |
+|------|------|
+| `ts-script` | TypeScript 腳本／工具專案，內含 neverthrow、ts-pattern、eslint、tsx、rolldown |
+
+## 開發
+
+```bash
+pnpm install
+pnpm dev       # 監聽模式
+pnpm build     # 用 rolldown 打包
+pnpm check     # 型別檢查
+pnpm lint      # eslint
+```
+
+## 更新紀錄
+
+請見 [CHANGELOG.md](./CHANGELOG.md)。
+
+## 授權
+
+[MIT](./LICENSE) © Bryan Chu

package/dist/index.js

@@ -452,6 +452,17 @@ function R$2({ input: r = stdin, output: t = stdout, overwrite: s = !0, hideCurs
 	};
 }
 const A$1 = (r) => "columns" in r && typeof r.columns == "number" ? r.columns : 80, L$1 = (r) => "rows" in r && typeof r.rows == "number" ? r.rows : 20;
+function W(r, t, s, e = s, i = s, n) {
+	return wrapAnsi(t, A$1(r ?? stdout) - s.length, {
+		hard: !0,
+		trim: !1
+	}).split(`
+`).map((u, a, l) => {
+		const c = n ? n(u, a) : u;
+		return a === 0 ? `${e}${c}` : a === l.length - 1 ? `${i}${c}` : `${s}${c}`;
+	}).join(`
+`);
+}
 let m$1 = class {
 	input;
 	output;
@@ -602,6 +613,33 @@ let m$1 = class {
 		}
 	}
 };
+var ut$1 = class extends m$1 {
+	options;
+	cursor = 0;
+	get _selectedValue() {
+		return this.options[this.cursor];
+	}
+	changeValue() {
+		this.value = this._selectedValue.value;
+	}
+	constructor(t) {
+		super(t, !1), this.options = t.options;
+		const s = this.options.findIndex(({ value: i }) => i === t.initialValue), e = s === -1 ? 0 : s;
+		this.cursor = this.options[e].disabled ? f$1(e, 1, this.options) : e, this.changeValue(), this.on("cursor", (i) => {
+			switch (i) {
+				case "left":
+				case "up":
+					this.cursor = f$1(this.cursor, -1, this.options);
+					break;
+				case "down":
+				case "right":
+					this.cursor = f$1(this.cursor, 1, this.options);
+					break;
+			}
+			this.changeValue();
+		});
+	}
+};
 var ht$1 = class extends m$1 {
 	get userInputWithCursor() {
 		if (this.state === "submit") return this.userInput;
@@ -629,7 +667,7 @@ var ht$1 = class extends m$1 {
 function ee() {
 	return V.platform !== "win32" ? V.env.TERM !== "linux" : !!V.env.CI || !!V.env.WT_SESSION || !!V.env.TERMINUS_SUBLIME || V.env.ConEmuTask === "{cmd::Cmder}" || V.env.TERM_PROGRAM === "Terminus-Sublime" || V.env.TERM_PROGRAM === "vscode" || V.env.TERM === "xterm-256color" || V.env.TERM === "alacritty" || V.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
-const tt = ee(), ot = () => process.env.CI === "true", w$1 = (t, i) => tt ? t : i, Tt = w$1("◆", "*"), at = w$1("■", "x"), ut = w$1("▲", "x"), H = w$1("◇", "o"), lt = w$1("┌", "T"), $ = w$1("│", "|"), x$1 = w$1("└", "—"), ht = w$1("●", "•"), pt = w$1("◆", "*"), mt = w$1("▲", "!"), gt = w$1("■", "x"), P$1 = (t) => {
+const tt = ee(), ot = () => process.env.CI === "true", w$1 = (t, i) => tt ? t : i, Tt = w$1("◆", "*"), at = w$1("■", "x"), ut = w$1("▲", "x"), H = w$1("◇", "o"), lt = w$1("┌", "T"), $ = w$1("│", "|"), x$1 = w$1("└", "—"), z$1 = w$1("●", ">"), U = w$1("○", " "), ht = w$1("●", "•"), pt = w$1("◆", "*"), mt = w$1("▲", "!"), gt = w$1("■", "x"), P$1 = (t) => {
 	switch (t) {
 		case "initial":
 		case "active": return styleText("cyan", Tt);
@@ -637,6 +675,50 @@ const tt = ee(), ot = () => process.env.CI === "true", w$1 = (t, i) => tt ? t :
 		case "error": return styleText("yellow", ut);
 		case "submit": return styleText("green", H);
 	}
+}, yt = (t) => {
+	switch (t) {
+		case "initial":
+		case "active": return styleText("cyan", $);
+		case "cancel": return styleText("red", $);
+		case "error": return styleText("yellow", $);
+		case "submit": return styleText("green", $);
+	}
+}, Ot = (t, i, s, r, u, n = !1) => {
+	let a = i, c = 0;
+	if (n) for (let o = r - 1; o >= s && (a -= t[o].length, c++, !(a <= u)); o--);
+	else for (let o = s; o < r && (a -= t[o].length, c++, !(a <= u)); o++);
+	return {
+		lineCount: a,
+		removals: c
+	};
+}, F$1 = ({ cursor: t, options: i, style: s, output: r = process.stdout, maxItems: u = Number.POSITIVE_INFINITY, columnPadding: n = 0, rowPadding: a = 4 }) => {
+	const c = A$1(r) - n, o = L$1(r), l = styleText("dim", "..."), d = Math.max(o - a, 0), g = Math.max(Math.min(u, d), 5);
+	let p = 0;
+	t >= g - 3 && (p = Math.max(Math.min(t - g + 3, i.length - g), 0));
+	let f = g < i.length && p > 0, h = g < i.length && p + g < i.length;
+	const I = Math.min(p + g, i.length), m = [];
+	let y = 0;
+	f && y++, h && y++;
+	const v = p + (f ? 1 : 0), C = I - (h ? 1 : 0);
+	for (let b = v; b < C; b++) {
+		const G = wrapAnsi(s(i[b], b === t), c, {
+			hard: !0,
+			trim: !1
+		}).split(`
+`);
+		m.push(G), y += G.length;
+	}
+	if (y > d) {
+		let b = 0, G = 0, M = y;
+		const N = t - v;
+		let O = d;
+		const j = () => Ot(m, M, 0, N, O), k = () => Ot(m, M, N + 1, m.length, O, !0);
+		f ? ({lineCount: M, removals: b} = j(), M > O && (h || (O -= 1), {lineCount: M, removals: G} = k())) : (h || (O -= 1), {lineCount: M, removals: G} = k(), M > O && (O -= 1, {lineCount: M, removals: b} = j())), b > 0 && (f = !0, m.splice(0, b)), G > 0 && (h = !0, m.splice(m.length - G, G));
+	}
+	const S = [];
+	f && S.push(l);
+	for (const b of m) for (const G of b) S.push(G);
+	return h && S.push(l), S;
 };
 const R$1 = {
 	message: (t = [], { symbol: i = styleText("gray", $), secondarySymbol: s = styleText("gray", $), output: r = process.stdout, spacing: u = 1, withGuide: n } = {}) => {
@@ -776,6 +858,59 @@ ${styleText("gray", x$1)}  ` : "";
 			return f;
 		}
 	};
+}, it = (t, i) => t.includes(`
+`) ? t.split(`
+`).map((s) => i(s)).join(`
+`) : i(t), xe = (t) => {
+	const i = (s, r) => {
+		const u = s.label ?? String(s.value);
+		switch (r) {
+			case "disabled": return `${styleText("gray", U)} ${it(u, (n) => styleText("gray", n))}${s.hint ? ` ${styleText("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+			case "selected": return `${it(u, (n) => styleText("dim", n))}`;
+			case "active": return `${styleText("green", z$1)} ${u}${s.hint ? ` ${styleText("dim", `(${s.hint})`)}` : ""}`;
+			case "cancelled": return `${it(u, (n) => styleText(["strikethrough", "dim"], n))}`;
+			default: return `${styleText("dim", U)} ${it(u, (n) => styleText("dim", n))}`;
+		}
+	};
+	return new ut$1({
+		options: t.options,
+		signal: t.signal,
+		input: t.input,
+		output: t.output,
+		initialValue: t.initialValue,
+		render() {
+			const s = t.withGuide ?? h$1.withGuide, r = `${P$1(this.state)}  `, u = `${yt(this.state)}  `, n = W(t.output, t.message, u, r), a = `${s ? `${styleText("gray", $)}
+` : ""}${n}
+`;
+			switch (this.state) {
+				case "submit": {
+					const c = s ? `${styleText("gray", $)}  ` : "";
+					return `${a}${W(t.output, i(this.options[this.cursor], "selected"), c)}`;
+				}
+				case "cancel": {
+					const c = s ? `${styleText("gray", $)}  ` : "";
+					return `${a}${W(t.output, i(this.options[this.cursor], "cancelled"), c)}${s ? `
+${styleText("gray", $)}` : ""}`;
+				}
+				default: {
+					const c = s ? `${styleText("cyan", $)}  ` : "", o = s ? styleText("cyan", x$1) : "", l = a.split(`
+`).length, d = s ? 2 : 1;
+					return `${a}${c}${F$1({
+						output: t.output,
+						cursor: this.cursor,
+						options: this.options,
+						maxItems: t.maxItems,
+						columnPadding: c.length,
+						rowPadding: l + d,
+						style: (g, p) => i(g, g.disabled ? "disabled" : p ? "active" : "inactive")
+					}).join(`
+${c}`)}
+${o}
+`;
+				}
+			}
+		}
+	}).prompt();
 }, Nt = `${styleText("gray", $)}  `, q = {
 	message: async (t, { symbol: i = styleText("gray", $) } = {}) => {
 		process.stdout.write(`${styleText("gray", $)}
@@ -835,26 +970,516 @@ ${i ? styleText("cyan", x$1) : ""}
 	}
 }).prompt();
 //#endregion
-//#region src/constants/deps.ts
-const DEPS = ["ts-pattern"];
-const DEV_DEPS = [
-	"@antfu/eslint-config",
-	"eslint",
-	"rolldown",
-	"tsx",
-	"typescript"
-];
+//#region node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.cjs.js
+var require_index_cjs = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const defaultErrorConfig = { withStackTrace: false };
+	const createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+		return {
+			data: result.isOk() ? {
+				type: "Ok",
+				value: result.value
+			} : {
+				type: "Err",
+				value: result.error
+			},
+			message,
+			stack: config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0
+		};
+	};
+	/******************************************************************************
+	Copyright (c) Microsoft Corporation.
+	
+	Permission to use, copy, modify, and/or distribute this software for any
+	purpose with or without fee is hereby granted.
+	
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+	PERFORMANCE OF THIS SOFTWARE.
+	***************************************************************************** */
+	function __awaiter(thisArg, _arguments, P, generator) {
+		function adopt(value) {
+			return value instanceof P ? value : new P(function(resolve) {
+				resolve(value);
+			});
+		}
+		return new (P || (P = Promise))(function(resolve, reject) {
+			function fulfilled(value) {
+				try {
+					step(generator.next(value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function rejected(value) {
+				try {
+					step(generator["throw"](value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function step(result) {
+				result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+			}
+			step((generator = generator.apply(thisArg, _arguments || [])).next());
+		});
+	}
+	function __values(o) {
+		var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+		if (m) return m.call(o);
+		if (o && typeof o.length === "number") return { next: function() {
+			if (o && i >= o.length) o = void 0;
+			return {
+				value: o && o[i++],
+				done: !o
+			};
+		} };
+		throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+	}
+	function __await(v) {
+		return this instanceof __await ? (this.v = v, this) : new __await(v);
+	}
+	function __asyncGenerator(thisArg, _arguments, generator) {
+		if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+		var g = generator.apply(thisArg, _arguments || []), i, q = [];
+		return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+			return this;
+		}, i;
+		function awaitReturn(f) {
+			return function(v) {
+				return Promise.resolve(v).then(f, reject);
+			};
+		}
+		function verb(n, f) {
+			if (g[n]) {
+				i[n] = function(v) {
+					return new Promise(function(a, b) {
+						q.push([
+							n,
+							v,
+							a,
+							b
+						]) > 1 || resume(n, v);
+					});
+				};
+				if (f) i[n] = f(i[n]);
+			}
+		}
+		function resume(n, v) {
+			try {
+				step(g[n](v));
+			} catch (e) {
+				settle(q[0][3], e);
+			}
+		}
+		function step(r) {
+			r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+		}
+		function fulfill(value) {
+			resume("next", value);
+		}
+		function reject(value) {
+			resume("throw", value);
+		}
+		function settle(f, v) {
+			if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+		}
+	}
+	function __asyncDelegator(o) {
+		var i, p;
+		return i = {}, verb("next"), verb("throw", function(e) {
+			throw e;
+		}), verb("return"), i[Symbol.iterator] = function() {
+			return this;
+		}, i;
+		function verb(n, f) {
+			i[n] = o[n] ? function(v) {
+				return (p = !p) ? {
+					value: __await(o[n](v)),
+					done: false
+				} : f ? f(v) : v;
+			} : f;
+		}
+	}
+	function __asyncValues(o) {
+		if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+		var m = o[Symbol.asyncIterator], i;
+		return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+			return this;
+		}, i);
+		function verb(n) {
+			i[n] = o[n] && function(v) {
+				return new Promise(function(resolve, reject) {
+					v = o[n](v), settle(resolve, reject, v.done, v.value);
+				});
+			};
+		}
+		function settle(resolve, reject, d, v) {
+			Promise.resolve(v).then(function(v) {
+				resolve({
+					value: v,
+					done: d
+				});
+			}, reject);
+		}
+	}
+	var ResultAsync = class ResultAsync {
+		constructor(res) {
+			this._promise = res;
+		}
+		static fromSafePromise(promise) {
+			return new ResultAsync(promise.then((value) => new Ok(value)));
+		}
+		static fromPromise(promise, errorFn) {
+			return new ResultAsync(promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e))));
+		}
+		static fromThrowable(fn, errorFn) {
+			return (...args) => {
+				return new ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+					try {
+						return new Ok(yield fn(...args));
+					} catch (error) {
+						return new Err(errorFn ? errorFn(error) : error);
+					}
+				}))());
+			};
+		}
+		static combine(asyncResultList) {
+			return combineResultAsyncList(asyncResultList);
+		}
+		static combineWithAllErrors(asyncResultList) {
+			return combineResultAsyncListWithAllErrors(asyncResultList);
+		}
+		map(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isErr()) return new Err(res.error);
+				return new Ok(yield f(res.value));
+			})));
+		}
+		andThrough(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isErr()) return new Err(res.error);
+				const newRes = yield f(res.value);
+				if (newRes.isErr()) return new Err(newRes.error);
+				return new Ok(res.value);
+			})));
+		}
+		andTee(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isErr()) return new Err(res.error);
+				try {
+					yield f(res.value);
+				} catch (e) {}
+				return new Ok(res.value);
+			})));
+		}
+		orTee(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isOk()) return new Ok(res.value);
+				try {
+					yield f(res.error);
+				} catch (e) {}
+				return new Err(res.error);
+			})));
+		}
+		mapErr(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isOk()) return new Ok(res.value);
+				return new Err(yield f(res.error));
+			})));
+		}
+		andThen(f) {
+			return new ResultAsync(this._promise.then((res) => {
+				if (res.isErr()) return new Err(res.error);
+				const newValue = f(res.value);
+				return newValue instanceof ResultAsync ? newValue._promise : newValue;
+			}));
+		}
+		orElse(f) {
+			return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+				if (res.isErr()) return f(res.error);
+				return new Ok(res.value);
+			})));
+		}
+		match(ok, _err) {
+			return this._promise.then((res) => res.match(ok, _err));
+		}
+		unwrapOr(t) {
+			return this._promise.then((res) => res.unwrapOr(t));
+		}
+		/**
+		* @deprecated will be removed in 9.0.0.
+		*
+		* You can use `safeTry` without this method.
+		* @example
+		* ```typescript
+		* safeTry(async function* () {
+		*   const okValue = yield* yourResult
+		* })
+		* ```
+		* Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+		*/
+		safeUnwrap() {
+			return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+				return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+			});
+		}
+		then(successCallback, failureCallback) {
+			return this._promise.then(successCallback, failureCallback);
+		}
+		[Symbol.asyncIterator]() {
+			return __asyncGenerator(this, arguments, function* _a() {
+				const result = yield __await(this._promise);
+				if (result.isErr()) yield yield __await(errAsync(result.error));
+				return yield __await(result.value);
+			});
+		}
+	};
+	function okAsync(value) {
+		return new ResultAsync(Promise.resolve(new Ok(value)));
+	}
+	function errAsync(err) {
+		return new ResultAsync(Promise.resolve(new Err(err)));
+	}
+	const fromPromise = ResultAsync.fromPromise;
+	const fromSafePromise = ResultAsync.fromSafePromise;
+	const fromAsyncThrowable = ResultAsync.fromThrowable;
+	/**
+	* Short circuits on the FIRST Err value that we find
+	*/
+	const combineResultList = (resultList) => {
+		let acc = ok([]);
+		for (const result of resultList) if (result.isErr()) {
+			acc = err(result.error);
+			break;
+		} else acc.map((list) => list.push(result.value));
+		return acc;
+	};
+	const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+	/**
+	* Give a list of all the errors we find
+	*/
+	const combineResultListWithAllErrors = (resultList) => {
+		let acc = ok([]);
+		for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
+		else if (result.isErr() && acc.isOk()) acc = err([result.error]);
+		else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
+		return acc;
+	};
+	const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+	exports.Result = void 0;
+	(function(Result) {
+		/**
+		* Wraps a function with a try catch, creating a new function with the same
+		* arguments but returning `Ok` if successful, `Err` if the function throws
+		*
+		* @param fn function to wrap with ok on success or err on failure
+		* @param errorFn when an error is thrown, this will wrap the error result if provided
+		*/
+		function fromThrowable(fn, errorFn) {
+			return (...args) => {
+				try {
+					return ok(fn(...args));
+				} catch (e) {
+					return err(errorFn ? errorFn(e) : e);
+				}
+			};
+		}
+		Result.fromThrowable = fromThrowable;
+		function combine(resultList) {
+			return combineResultList(resultList);
+		}
+		Result.combine = combine;
+		function combineWithAllErrors(resultList) {
+			return combineResultListWithAllErrors(resultList);
+		}
+		Result.combineWithAllErrors = combineWithAllErrors;
+	})(exports.Result || (exports.Result = {}));
+	function ok(value) {
+		return new Ok(value);
+	}
+	function err(err) {
+		return new Err(err);
+	}
+	function safeTry(body) {
+		const n = body().next();
+		if (n instanceof Promise) return new ResultAsync(n.then((r) => r.value));
+		return n.value;
+	}
+	var Ok = class {
+		constructor(value) {
+			this.value = value;
+		}
+		isOk() {
+			return true;
+		}
+		isErr() {
+			return !this.isOk();
+		}
+		map(f) {
+			return ok(f(this.value));
+		}
+		mapErr(_f) {
+			return ok(this.value);
+		}
+		andThen(f) {
+			return f(this.value);
+		}
+		andThrough(f) {
+			return f(this.value).map((_value) => this.value);
+		}
+		andTee(f) {
+			try {
+				f(this.value);
+			} catch (e) {}
+			return ok(this.value);
+		}
+		orTee(_f) {
+			return ok(this.value);
+		}
+		orElse(_f) {
+			return ok(this.value);
+		}
+		asyncAndThen(f) {
+			return f(this.value);
+		}
+		asyncAndThrough(f) {
+			return f(this.value).map(() => this.value);
+		}
+		asyncMap(f) {
+			return ResultAsync.fromSafePromise(f(this.value));
+		}
+		unwrapOr(_v) {
+			return this.value;
+		}
+		match(ok, _err) {
+			return ok(this.value);
+		}
+		safeUnwrap() {
+			const value = this.value;
+			return (function* () {
+				return value;
+			})();
+		}
+		_unsafeUnwrap(_) {
+			return this.value;
+		}
+		_unsafeUnwrapErr(config) {
+			throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+		}
+		*[Symbol.iterator]() {
+			return this.value;
+		}
+	};
+	var Err = class {
+		constructor(error) {
+			this.error = error;
+		}
+		isOk() {
+			return false;
+		}
+		isErr() {
+			return !this.isOk();
+		}
+		map(_f) {
+			return err(this.error);
+		}
+		mapErr(f) {
+			return err(f(this.error));
+		}
+		andThrough(_f) {
+			return err(this.error);
+		}
+		andTee(_f) {
+			return err(this.error);
+		}
+		orTee(f) {
+			try {
+				f(this.error);
+			} catch (e) {}
+			return err(this.error);
+		}
+		andThen(_f) {
+			return err(this.error);
+		}
+		orElse(f) {
+			return f(this.error);
+		}
+		asyncAndThen(_f) {
+			return errAsync(this.error);
+		}
+		asyncAndThrough(_f) {
+			return errAsync(this.error);
+		}
+		asyncMap(_f) {
+			return errAsync(this.error);
+		}
+		unwrapOr(v) {
+			return v;
+		}
+		match(_ok, err) {
+			return err(this.error);
+		}
+		safeUnwrap() {
+			const error = this.error;
+			return (function* () {
+				yield err(error);
+				throw new Error("Do not use this generator out of `safeTry`");
+			})();
+		}
+		_unsafeUnwrap(config) {
+			throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+		}
+		_unsafeUnwrapErr(_) {
+			return this.error;
+		}
+		*[Symbol.iterator]() {
+			const self = this;
+			yield self;
+			return self;
+		}
+	};
+	const fromThrowable = exports.Result.fromThrowable;
+	exports.Err = Err;
+	exports.Ok = Ok;
+	exports.ResultAsync = ResultAsync;
+	exports.err = err;
+	exports.errAsync = errAsync;
+	exports.fromAsyncThrowable = fromAsyncThrowable;
+	exports.fromPromise = fromPromise;
+	exports.fromSafePromise = fromSafePromise;
+	exports.fromThrowable = fromThrowable;
+	exports.ok = ok;
+	exports.okAsync = okAsync;
+	exports.safeTry = safeTry;
+}));
 //#endregion
 //#region src/constants/questions.ts
 const DEFAULT_PROJECT_NAME = "ts-start";
 //#endregion
+//#region src/constants/templates.ts
+const TEMPLATES = [{
+	value: "ts-script",
+	label: "ts-script",
+	hint: "TypeScript script/tooling",
+	deps: ["ts-pattern", "neverthrow"],
+	devDeps: [
+		"eslint",
+		"@antfu/eslint-config",
+		"tsx",
+		"typescript",
+		"rolldown"
+	]
+}];
+//#endregion
 //#region src/utils/get-latest-ver.ts
-async function getLatestVer(pkg) {
+var import_index_cjs = require_index_cjs();
+function getLatestVer(pkg) {
 	const encoded = pkg.startsWith("@") ? pkg.replace("/", "%2F") : pkg;
-	const res = await fetch(`https://registry.npmjs.org/${encoded}/latest`);
-	if (!res.ok) throw new Error(`Failed to fetch version for ${pkg}`);
-	const { version } = await res.json();
-	return `^${version}`;
+	return (0, import_index_cjs.fromPromise)(fetch(`https://registry.npmjs.org/${encoded}/latest`), (e) => e).andThen((response) => response.ok ? (0, import_index_cjs.fromPromise)(response.json(), (e) => e) : (0, import_index_cjs.err)(/* @__PURE__ */ new Error(`Failed to fetch version for ${pkg}`))).map(({ version }) => `^${version}`);
 }
 //#endregion
 //#region node_modules/.pnpm/ts-pattern@5.9.0/node_modules/ts-pattern/dist/index.js
@@ -1260,64 +1885,107 @@ function F(t) {
 }
 //#endregion
 //#region src/utils/get-project-name.ts
-async function getProjectName() {
-	return argv[2]?.trim() || await askProjectName();
-}
-async function askProjectName() {
-	return M(await Pe({
+function getProjectName() {
+	const cliArg = argv[2]?.trim();
+	return cliArg ? (0, import_index_cjs.okAsync)(cliArg) : (0, import_index_cjs.fromPromise)(Pe({
 		message: "Project name",
 		placeholder: DEFAULT_PROJECT_NAME,
-		defaultValue: DEFAULT_PROJECT_NAME
-	})).with(z.string, (name) => name).with(z.when(q$1), () => {
-		me("Operation cancelled");
-		exit(0);
-	}).exhaustive();
+		defaultValue: DEFAULT_PROJECT_NAME,
+		validate: validateProjectName
+	}), (e) => e).andThen((answer) => M(answer).with(z.when(q$1), () => (0, import_index_cjs.err)(/* @__PURE__ */ new Error("Operation cancelled"))).with(z.string, (name) => (0, import_index_cjs.ok)(name)).exhaustive());
+}
+function validateProjectName(value) {
+	const name = value ?? "";
+	return [[(n) => /^[a-z0-9][a-z0-9-_]*$/.test(n), "Only lowercase letters, numbers, hyphens, and underscores"], [(n) => !n.startsWith("."), "Name cannot start with a dot"]].find(([predicate]) => !predicate(name))?.[1];
+}
+//#endregion
+//#region src/utils/get-template.ts
+function getTemplate() {
+	return (0, import_index_cjs.fromPromise)(xe({
+		message: "Select a template",
+		options: [...TEMPLATES]
+	}), (e) => e).andThen((answer) => M(answer).with(z.when(q$1), () => (0, import_index_cjs.err)(/* @__PURE__ */ new Error("Operation cancelled"))).with(z.string, (t) => (0, import_index_cjs.ok)(t)).exhaustive());
 }
 //#endregion
 //#region src/utils/resolve-new-dir.ts
 function resolveNewDir(projectName) {
 	const targetDir = resolve(cwd(), projectName);
-	if (existsSync(targetDir)) {
-		me(`Directory already exists: ${targetDir}`);
-		exit(1);
-	}
-	return targetDir;
+	return !existsSync(targetDir) ? (0, import_index_cjs.ok)(targetDir) : (0, import_index_cjs.err)(/* @__PURE__ */ new Error(`Directory already exists: ${targetDir}`));
 }
 //#endregion
 //#region src/index.ts
-async function main() {
+(async () => {
 	ge("create-template-ts");
-	const projectName = await getProjectName();
-	const targetDir = resolveNewDir(projectName);
-	const s = ft();
-	s.start("Fetching latest package versions");
-	const [depVers, devDepVers] = await Promise.all([Promise.all(DEPS.map(async (dep) => [dep, await getLatestVer(dep)])), Promise.all(DEV_DEPS.map(async (dep) => [dep, await getLatestVer(dep)]))]);
-	const deps = { ...Object.fromEntries(depVers) };
-	const devDeps = {
-		...Object.fromEntries(devDepVers),
-		"@types/node": `^${version.match(/^v(\d+)/)?.[1]}`
-	};
-	s.stop("Fetched latest package versions");
-	const templateDir = join(import.meta.dirname, "../template");
-	mkdirSync(targetDir, { recursive: true });
-	cpSync(templateDir, targetDir, { recursive: true });
-	const gitignoreSrc = join(targetDir, "_gitignore");
-	const gitignoreDst = join(targetDir, ".gitignore");
-	if (existsSync(gitignoreSrc)) renameSync(gitignoreSrc, gitignoreDst);
-	const vscodeSrc = join(targetDir, "_vscode");
-	const vscodeDst = join(targetDir, ".vscode");
-	if (existsSync(vscodeSrc)) renameSync(vscodeSrc, vscodeDst);
-	const pkgPath = join(targetDir, "package.json");
-	const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-	pkg.name = basename(projectName);
-	pkg.dependencies = deps;
-	pkg.devDependencies = devDeps;
-	writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 4)}\n`);
-	ye(`Done! Run:\n\n  cd ${projectName}\n  pnpm install`);
+	await getProjectName().andThen((projectName) => getTemplate().map((template) => ({
+		projectName,
+		template
+	}))).andThen(({ projectName, template }) => resolveNewDir(projectName).map((targetDir) => ({
+		projectName,
+		template,
+		targetDir
+	}))).andThen(({ projectName, template, targetDir }) => {
+		const { deps, devDeps } = TEMPLATES.find((t) => t.value === template);
+		const s = ft();
+		s.start("Fetching latest package versions");
+		return import_index_cjs.ResultAsync.combine([import_index_cjs.ResultAsync.combine([...deps].map((dep) => getLatestVer(dep))), import_index_cjs.ResultAsync.combine([...devDeps].map((dep) => getLatestVer(dep)))]).map(([depVers, devDepVers]) => {
+			s.stop("Fetched latest package versions");
+			return {
+				projectName,
+				template,
+				targetDir,
+				deps,
+				devDeps,
+				depVers,
+				devDepVers
+			};
+		}).mapErr((error) => {
+			s.stop("Failed to fetch package versions");
+			return error;
+		});
+	}).andThen(({ projectName, template, targetDir, deps, devDeps, depVers, devDepVers }) => {
+		const depsMap = Object.fromEntries(deps.map((dep, i) => [dep, depVers[i]]));
+		const devDepsMap = {
+			...Object.fromEntries(devDeps.map((dep, i) => [dep, devDepVers[i]])),
+			"@types/node": `^${version.match(/^v(\d+)/)?.[1]}`
+		};
+		const templateDir = join(import.meta.dirname, "../templates", template);
+		const pkgPath = join(targetDir, "package.json");
+		return safeMkdirSync(targetDir, { recursive: true }).andThen(() => safeCpSync(templateDir, targetDir, { recursive: true })).andThen(() => {
+			const src = join(targetDir, "_gitignore");
+			const dst = join(targetDir, ".gitignore");
+			return existsSync(src) ? safeRenameSync(src, dst) : (0, import_index_cjs.ok)(void 0);
+		}).andThen(() => {
+			const src = join(targetDir, "_vscode");
+			const dst = join(targetDir, ".vscode");
+			return existsSync(src) ? safeRenameSync(src, dst) : (0, import_index_cjs.ok)(void 0);
+		}).andThen(() => safeReadFileSync(pkgPath)).andThen((content) => safeJsonParse(content)).andThen((pkg) => {
+			pkg.name = basename(projectName);
+			pkg.dependencies = depsMap;
+			pkg.devDependencies = devDepsMap;
+			return safeWriteFileSync(pkgPath, `${JSON.stringify(pkg, null, 4)}\n`);
+		}).map(() => projectName);
+	}).match((projectName) => ye(`Done! Run:\n\n  cd ${projectName}\n  pnpm install`), (err) => {
+		me(err.message);
+		exit(1);
+	});
+})();
+function safeMkdirSync(path, options) {
+	return (0, import_index_cjs.fromThrowable)(mkdirSync, (e) => e)(path, options);
+}
+function safeCpSync(src, dest, options) {
+	return (0, import_index_cjs.fromThrowable)(cpSync, (e) => e)(src, dest, options);
+}
+function safeRenameSync(oldPath, newPath) {
+	return (0, import_index_cjs.fromThrowable)(renameSync, (e) => e)(oldPath, newPath);
+}
+function safeReadFileSync(path) {
+	return (0, import_index_cjs.fromThrowable)((p) => readFileSync(p, "utf8"), (e) => e)(path);
+}
+function safeWriteFileSync(path, data) {
+	return (0, import_index_cjs.fromThrowable)(writeFileSync, (e) => e)(path, data);
+}
+function safeJsonParse(text) {
+	return (0, import_index_cjs.fromThrowable)((t) => JSON.parse(t), (e) => e)(text);
 }
-main().catch((err) => {
-	console.error(err);
-	exit(1);
-});
 //#endregion
 export {};

package/package.json

@@ -1,8 +1,10 @@
 {
     "name": "@bryanchu10/create-template-ts",
     "type": "module",
-    "version": "1.0.2",
+    "version": "1.1.0",
     "description": "Scaffold a modular TypeScript project for scripts and tooling",
+    "author": "Bryan Chu <bryanchu10@gmail.com> (https://github.com/bryanchu10)",
+    "license": "MIT",
     "repository": {
         "type": "git",
         "url": "https://github.com/bryanchu10/create-template-ts"
@@ -10,7 +12,7 @@
     "bin": "./dist/index.js",
     "files": [
         "dist",
-        "template"
+        "templates"
     ],
     "scripts": {
         "dev": "tsx watch src/index.ts",
@@ -21,6 +23,7 @@
     },
     "dependencies": {
         "@clack/prompts": "^1.4.0",
+        "neverthrow": "^8.2.0",
         "ts-pattern": "^5.9.0"
     },
     "devDependencies": {

package/{template → templates/ts-script}/eslint.config.js

@@ -14,9 +14,24 @@ export default antfu(
                 "style/jsx-max-props-per-line": "off",
                 "style/jsx-closing-bracket-location": ["error", "after-props"],
                 "style/operator-linebreak": ["error", "before"],
+                "style/padding-line-between-statements": [
+                    "error",
+                    { blankLine: "always", prev: "*", next: "for" },
+                    { blankLine: "always", prev: "for", next: "*" },
+                    { blankLine: "always", prev: "*", next: "return" },
+                ],
             },
         },
     },
+    {
+        rules: {
+            "new-cap": ["error", {
+                capIsNew: true,
+                newIsCap: true,
+                properties: true,
+            }],
+        },
+    },
     {
         files: ["pnpm-workspace.yaml"],
         rules: {