pomotty 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pomotty",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "An interactive terminal Pomodoro timer with configurable work and break sessions and sound notifications.",
   "keywords": [
     "cli",
@@ -19,22 +19,25 @@
     "url": "git+https://github.com/iririn1998/pomotty.git"
   },
   "bin": {
-    "pomotty": "dist/bin/pomotty.js"
+    "pomotty": "dist/cli.js"
   },
   "files": [
-    "dist/bin/pomotty.js",
+    "dist/cli.js",
     "assets/*.wav"
   ],
   "type": "module",
+  "imports": {
+    "#src/*": "./src/*"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "22.20.1",
     "oxfmt": "^0.61.0",
     "oxlint": "^1.76.0",
-    "rolldown": "^1.2.3",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
@@ -48,12 +51,14 @@
     "node": "^22.18.0 || >=24.11.0"
   },
   "scripts": {
-    "build": "rolldown -c rolldown.config.mjs",
-    "start": "pnpm build && node dist/bin/pomotty.js",
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
+    "check": "pnpm typecheck && pnpm build && pnpm test",
+    "start": "pnpm build && node dist/cli.js",
     "lint": "oxlint . --deny-warnings --report-unused-disable-directives-severity=error",
     "lint:fix": "oxlint . --fix --deny-warnings --report-unused-disable-directives-severity=error",
     "format": "oxfmt --write",
     "format:check": "oxfmt --check",
-    "test": "vitest run"
+    "test": "vitest run --dir src"
   }
 }

package/dist/bin/pomotty.js

@@ -1,483 +0,0 @@
-#!/usr/bin/env node
-import process$1 from "node:process";
-import { setTimeout } from "node:timers/promises";
-import { on } from "node:events";
-import { emitKeypressEvents } from "node:readline";
-import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
-const MILLISECONDS_PER_MINUTE = 6e4;
-const DEFAULT_BREAK_DURATION_MS = 5 * MILLISECONDS_PER_MINUTE;
-const DEFAULT_WORK_DURATION_MS = 15 * MILLISECONDS_PER_MINUTE;
-const waitFor = (durationMs) => setTimeout(durationMs);
-const runPomodoroCycle = async ({ workDurationMs = DEFAULT_WORK_DURATION_MS, breakDurationMs = DEFAULT_BREAK_DURATION_MS, wait = waitFor, onPhaseStarted, onPhaseCompleted } = {}) => {
-	if (onPhaseStarted) onPhaseStarted("work", workDurationMs);
-	await wait(workDurationMs);
-	if (onPhaseCompleted) onPhaseCompleted("work");
-	if (onPhaseStarted) onPhaseStarted("break", breakDurationMs);
-	await wait(breakDurationMs);
-	if (onPhaseCompleted) onPhaseCompleted("break");
-};
-const OPTIONS = [
-	{
-		description: `Work duration in minutes (1-1440, default: 15)`,
-		name: "--work",
-		valueName: "<minutes>"
-	},
-	{
-		description: `Break duration in minutes (1-1440, default: 5)`,
-		name: "--break",
-		valueName: "<minutes>"
-	},
-	{
-		description: `Work-break repetitions (positive integer, default: 3)`,
-		name: "--loop",
-		valueName: "<count>"
-	},
-	{
-		alias: "-h",
-		description: "Print help",
-		name: "--help"
-	}
-];
-//#endregion
-//#region src/terminal/input.ts
-const CHOICES = ["OK", "NG"];
-const CONTROL_C_KEY_NAME = "c";
-const ENTER_KEY_NAMES = /* @__PURE__ */ new Set(["enter", "return"]);
-const FIRST_CHOICE_INDEX = 0;
-const KEYPRESS_EVENT_KEY_INDEX = 1;
-const MOVE_KEY_NAMES = /* @__PURE__ */ new Set(["down", "up"]);
-const NEXT_INDEX_OFFSET = 1;
-const REDRAW_SEQUENCE = `\r\u001B[${CHOICES.length}A\u001B[J`;
-const SELECTION_QUESTION = "Start working? (Use ↑/↓ to select, Enter to confirm)";
-const keyFrom = (value) => {
-	let key = {}, normalizedName = "";
-	if (typeof value === "object" && value !== null) key = value;
-	const ctrl = Reflect.get(key, "ctrl"), name = Reflect.get(key, "name");
-	if (typeof name === "string") normalizedName = name;
-	return {
-		ctrl: ctrl === true,
-		name: normalizedName
-	};
-};
-const createSelectionTerminal = () => {
-	emitKeypressEvents(process$1.stdin);
-	const inputWasFlowing = process$1.stdin.readableFlowing === true, keypressEvents = on(process$1.stdin, "keypress"), rawModeWasEnabled = process$1.stdin.isRaw === true, supportsRawMode = process$1.stdin.isTTY === true;
-	let restored = false;
-	if (supportsRawMode && !rawModeWasEnabled) process$1.stdin.setRawMode(true);
-	if (!inputWasFlowing) process$1.stdin.resume();
-	return {
-		nextKey: async () => {
-			const event = await keypressEvents.next();
-			if (event.done) return {
-				ctrl: true,
-				name: CONTROL_C_KEY_NAME
-			};
-			return keyFrom(event.value.at(KEYPRESS_EVENT_KEY_INDEX));
-		},
-		restore: async () => {
-			if (restored) return;
-			restored = true;
-			const stopListening = keypressEvents.return;
-			if (stopListening) await stopListening.call(keypressEvents);
-			if (supportsRawMode && !rawModeWasEnabled) process$1.stdin.setRawMode(false);
-			if (!inputWasFlowing) process$1.stdin.pause();
-		},
-		write: (output) => {
-			process$1.stdout.write(output);
-		}
-	};
-};
-const markerFor = (selected) => {
-	if (selected) return "❯";
-	return " ";
-};
-const renderSelection = (selectedIndex) => [SELECTION_QUESTION, ...CHOICES.map((choice, index) => `${markerFor(index === selectedIndex)} ${choice}`)].join("\n");
-const nextChoiceIndex = (selectedIndex) => {
-	if (selectedIndex === FIRST_CHOICE_INDEX) return CHOICES.length - NEXT_INDEX_OFFSET;
-	return FIRST_CHOICE_INDEX;
-};
-const handleKey = (key, selectedIndex, terminal) => {
-	if (key.ctrl && key.name === CONTROL_C_KEY_NAME) {
-		terminal.write("\n");
-		return false;
-	}
-	if (MOVE_KEY_NAMES.has(key.name)) {
-		const newSelectedIndex = nextChoiceIndex(selectedIndex);
-		terminal.write(`${REDRAW_SEQUENCE}${renderSelection(newSelectedIndex)}`);
-		return newSelectedIndex;
-	}
-	if (ENTER_KEY_NAMES.has(key.name)) {
-		terminal.write("\n");
-		return CHOICES[selectedIndex] === "OK";
-	}
-	return selectedIndex;
-};
-const confirmWorkStart = async ({ createTerminal = createSelectionTerminal } = {}) => {
-	const terminal = createTerminal();
-	let selectedIndex = FIRST_CHOICE_INDEX;
-	terminal.write(renderSelection(selectedIndex));
-	try {
-		for (;;) {
-			const key = await terminal.nextKey(), selection = handleKey(key, selectedIndex, terminal);
-			if (typeof selection === "boolean") return selection;
-			selectedIndex = selection;
-		}
-	} finally {
-		await terminal.restore();
-	}
-};
-//#endregion
-//#region src/terminal/constants.ts
-/**
-* CLI起動時に表示するアスキーアートロゴです。
-*/
-const LOGO = `
-  ██████╗  ██████╗ ███╗   ███╗ ██████╗ ████████╗████████╗██╗   ██╗
-  ██╔══██╗██╔═══██╗████╗ ████║██╔═══██╗╚══██╔══╝╚══██╔══╝╚██╗ ██╔╝
-  ██████╔╝██║   ██║██╔████╔██║██║   ██║   ██║      ██║    ╚████╔╝ 
-  ██╔═══╝ ██║   ██║██║╚██╔╝██║██║   ██║   ██║      ██║     ╚██╔╝  
-  ██║     ╚██████╔╝██║ ╚═╝ ██║╚██████╔╝   ██║      ██║      ██║   
-  ╚═╝      ╚═════╝ ╚═╝     ╚═╝ ╚═════╝    ╚═╝      ╚═╝      ╚═╝
-`;
-//#endregion
-//#region src/terminal/render.ts
-/**
-* CLIへ渡されたオプションに応じた出力を生成します。
-*
-* オプションの名前または短縮形と一致した場合はヘルプを生成し、
-* 一致しない場合は通常起動時のロゴを返します。
-*
-* @param parameters CLI出力の生成に必要な値。
-* @returns 標準出力へ書き込む文字列。
-*/
-const CLI_OPTION_INDEX = 2;
-const createCliOutput = ({ options, optionName = process.argv.at(CLI_OPTION_INDEX) }) => {
-	if (!options.find(({ alias, name }) => alias === optionName || name === optionName)) return `${LOGO}\n`;
-	return [
-		"Pomotty CLI",
-		"",
-		"Usage: pomotty [OPTIONS]",
-		"",
-		"Options:",
-		...options.flatMap(({ alias, description, name, valueName }) => {
-			return [`  ${[alias, [name, valueName].filter(Boolean).join(" ")].filter(Boolean).join(", ")}`, `          ${description}`];
-		}),
-		""
-	].join("\n");
-};
-//#endregion
-//#region src/diagnostics/writer.ts
-/**
-* 診断の出力先が閉じていても失敗しない書き込み処理を生成します。
-*
-* 最初の書き込みより前に`error`リスナーを登録し、閉じたパイプなどで
-* 発生する非同期エラーを未処理の例外にしません。同期例外も握りつぶし、
-* 一度でも書き込みに失敗したら以後の診断を出力しません。
-* これにより出力先の状態が終了コードへ影響しなくなります。
-*
-* @param stream 診断の出力先。
-* @returns 出力先の状態にかかわらず例外を投げない書き込み処理。
-*/
-const createDiagnosticWriter = (stream = process$1.stderr) => {
-	let unavailable = false;
-	stream.on("error", () => {
-		unavailable = true;
-	});
-	return (output) => {
-		if (unavailable) return;
-		try {
-			stream.write(output);
-		} catch {
-			unavailable = true;
-		}
-	};
-};
-//#endregion
-//#region src/diagnostics/escape.ts
-const BACKSLASH = "\\";
-const BIDIRECTIONAL_PATTERN = /[\u061C\u200B\u200E\u200F\u2028-\u202E\u2066-\u206F\uFEFF]/u;
-const CONTROL_HEX_LENGTH = 2;
-const CONTROL_PATTERN = /[\u0000-\u001F\u007F-\u009F]/u;
-const EMPTY_CODE_POINT = 0;
-const FIRST_INDEX = 0;
-const HEXADECIMAL_RADIX = 16;
-const HEX_PAD_CHARACTER = "0";
-const MAXIMUM_CODE_POINTS = 160;
-const QUOTATION_MARK = "\"";
-const SURROGATE_HEX_LENGTH = 4;
-const SURROGATE_PATTERN = /[\uD800-\uDFFF]/u;
-const TRUNCATION_MARK = "…";
-const UNPADDED_HEX_LENGTH = 0;
-const characterToHexadecimal = (character, length) => (character.codePointAt(FIRST_INDEX) ?? EMPTY_CODE_POINT).toString(HEXADECIMAL_RADIX).toUpperCase().padStart(length, HEX_PAD_CHARACTER);
-const escapeUnsafeCharacter = (character) => {
-	if (CONTROL_PATTERN.test(character)) return String.raw`\x${characterToHexadecimal(character, CONTROL_HEX_LENGTH)}`;
-	if (BIDIRECTIONAL_PATTERN.test(character)) return String.raw`\u{${characterToHexadecimal(character, UNPADDED_HEX_LENGTH)}}`;
-	if (SURROGATE_PATTERN.test(character)) return String.raw`\u${characterToHexadecimal(character, SURROGATE_HEX_LENGTH)}`;
-	return character;
-};
-const escapeCharacter = (character) => {
-	if (character === BACKSLASH) return String.raw`\\`;
-	if (character === QUOTATION_MARK) return String.raw`\"`;
-	return escapeUnsafeCharacter(character);
-};
-const escapeDiagnostic = (value) => {
-	const codePoints = [...value], escaped = codePoints.slice(FIRST_INDEX, MAXIMUM_CODE_POINTS).map((character) => escapeCharacter(character)).join("");
-	if (codePoints.length > MAXIMUM_CODE_POINTS) return `${QUOTATION_MARK}${escaped}${TRUNCATION_MARK}${QUOTATION_MARK}`;
-	return `${QUOTATION_MARK}${escaped}${QUOTATION_MARK}`;
-};
-//#endregion
-//#region src/cli/parse-arguments.ts
-const ARGUMENT_INDEX_INCREMENT = 1;
-const ARGUMENTS_START_INDEX = 0;
-const DURATION_PATTERN = /^[1-9][0-9]{0,3}$/u;
-const EQUALS_SIGN = "=";
-const EQUALS_SIGN_NOT_FOUND = -1;
-const HELP_OPTIONS = ["--help", "-h"];
-const MAXIMUM_DURATION_MINUTES = 1440;
-const NEXT_ARGUMENT_OFFSET = 1;
-const LOOP_PATTERN = /^[1-9][0-9]*$/u;
-const isNumericOption = (value) => value === "--break" || value === "--work" || value === "--loop";
-const isHelpOption = (value) => HELP_OPTIONS.some((option) => option === value);
-const createValueError = (option) => {
-	let maximum = MAXIMUM_DURATION_MINUTES;
-	if (option === "--loop") maximum = Number.MAX_SAFE_INTEGER;
-	return {
-		kind: "error",
-		message: `Error: ${option} requires an integer from 1 to ${maximum}.\n`
-	};
-};
-const createDuplicateError = (option) => ({
-	kind: "error",
-	message: `Error: ${option} may only be specified once.\n`
-});
-const parseNumericValue = (option, value) => {
-	let pattern = DURATION_PATTERN, maximum = MAXIMUM_DURATION_MINUTES;
-	if (option === "--loop") {
-		pattern = LOOP_PATTERN;
-		maximum = Number.MAX_SAFE_INTEGER;
-	}
-	if (typeof value !== "string" || !pattern.test(value)) return;
-	const numericValue = Number(value);
-	if (!Number.isSafeInteger(numericValue) || numericValue > maximum) return;
-	return numericValue;
-};
-const parseNumericArgument = (argument, nextArgument) => {
-	const equalsSignIndex = argument.indexOf(EQUALS_SIGN);
-	if (equalsSignIndex === EQUALS_SIGN_NOT_FOUND) return {
-		consumesNextArgument: true,
-		optionName: argument,
-		value: nextArgument
-	};
-	return {
-		consumesNextArgument: false,
-		optionName: argument.slice(ARGUMENTS_START_INDEX, equalsSignIndex),
-		value: argument.slice(equalsSignIndex + NEXT_ARGUMENT_OFFSET)
-	};
-};
-const parseCliArguments = (arguments_) => {
-	if (arguments_.some((argument) => isHelpOption(argument))) return { kind: "help" };
-	const specifiedOptions = /* @__PURE__ */ new Set();
-	let breakDurationMinutes = 5, loopCount = 3, workDurationMinutes = 15;
-	for (let argumentIndex = ARGUMENTS_START_INDEX; argumentIndex < arguments_.length; argumentIndex += ARGUMENT_INDEX_INCREMENT) {
-		const argument = arguments_[argumentIndex] ?? "", { consumesNextArgument, optionName, value } = parseNumericArgument(argument, arguments_[argumentIndex + NEXT_ARGUMENT_OFFSET]);
-		if (!isNumericOption(optionName)) return {
-			kind: "error",
-			message: `Error: Unknown option: ${escapeDiagnostic(argument)}\n`
-		};
-		if (specifiedOptions.has(optionName)) return createDuplicateError(optionName);
-		const numericValue = parseNumericValue(optionName, value);
-		if (typeof numericValue !== "number") return createValueError(optionName);
-		specifiedOptions.add(optionName);
-		if (consumesNextArgument) argumentIndex += NEXT_ARGUMENT_OFFSET;
-		if (optionName === "--work") workDurationMinutes = numericValue;
-		else if (optionName === "--loop") loopCount = numericValue;
-		else breakDurationMinutes = numericValue;
-	}
-	return {
-		breakDurationMinutes,
-		kind: "run",
-		loopCount,
-		workDurationMinutes
-	};
-};
-//#endregion
-//#region src/notification/sound.ts
-const FIRST_COMMAND_INDEX = 0;
-const NEXT_COMMAND_OFFSET = 1;
-const SUCCESS_EXIT_CODE$1 = 0;
-const FALLBACK_SOUNDS = {
-	break: "\x07\x07",
-	work: "\x07"
-};
-const WINDOWS_SOUND_SCRIPT = [
-	"$player = New-Object System.Media.SoundPlayer",
-	"$player.SoundLocation = $env:POMOTTY_SOUND_FILE",
-	"$player.PlaySync()"
-].join("; ");
-const spawnSoundProcess = (command, commandArguments, options) => {
-	const child = spawn(command, [...commandArguments], options);
-	return {
-		onClose: (listener) => {
-			child.once("close", listener);
-		},
-		onError: (listener) => {
-			child.once("error", listener);
-		}
-	};
-};
-const soundFileFor = (phase) => fileURLToPath(new URL(`../../assets/${phase}-end.wav`, import.meta.url));
-const soundEnvironmentFor = (soundFile) => {
-	const environment = structuredClone(process$1.env);
-	environment.POMOTTY_SOUND_FILE = soundFile;
-	return environment;
-};
-const commandsFor = (platform, soundFile) => {
-	switch (platform) {
-		case "darwin": return [{
-			command: "/usr/bin/afplay",
-			commandArguments: [soundFile]
-		}];
-		case "linux": return [{
-			command: "paplay",
-			commandArguments: [soundFile]
-		}, {
-			command: "aplay",
-			commandArguments: [soundFile]
-		}];
-		case "win32": return [{
-			command: "powershell.exe",
-			commandArguments: [
-				"-NoProfile",
-				"-NonInteractive",
-				"-Command",
-				WINDOWS_SOUND_SCRIPT
-			],
-			env: soundEnvironmentFor(soundFile)
-		}];
-		default: return [];
-	}
-};
-const observeFailure = (child, onFailure) => {
-	let settled = false;
-	const failOnce = () => {
-		if (settled) return;
-		settled = true;
-		onFailure();
-	};
-	child.onError(failOnce);
-	child.onClose((code) => {
-		if (code !== SUCCESS_EXIT_CODE$1) failOnce();
-	});
-};
-const runSoundCommands = ({ commands, fallback, index, spawnProcess }) => {
-	const soundCommand = commands.at(index), tryNextCommand = () => {
-		runSoundCommands({
-			commands,
-			fallback,
-			index: index + NEXT_COMMAND_OFFSET,
-			spawnProcess
-		});
-	};
-	if (!soundCommand) {
-		fallback();
-		return;
-	}
-	try {
-		const child = spawnProcess(soundCommand.command, soundCommand.commandArguments, {
-			env: soundCommand.env,
-			stdio: "ignore",
-			windowsHide: true
-		});
-		observeFailure(child, tryNextCommand);
-	} catch {
-		tryNextCommand();
-	}
-};
-const playCompletionSound = (phase, { platform = process$1.platform, spawnProcess = spawnSoundProcess, writeFallback = (output) => {
-	process$1.stderr.write(output);
-} } = {}) => {
-	const commands = commandsFor(platform, soundFileFor(phase)), fallback = () => {
-		writeFallback(FALLBACK_SOUNDS[phase]);
-	};
-	runSoundCommands({
-		commands,
-		fallback,
-		index: FIRST_COMMAND_INDEX,
-		spawnProcess
-	});
-};
-//#endregion
-//#region src/cli/run.ts
-const CLI_ARGUMENTS_START_INDEX = 2;
-const COUNT_INCREMENT = 1;
-const PHASE_ICONS = {
-	break: "☕",
-	work: "🍅"
-};
-const PHASE_NAMES = {
-	break: "Break",
-	work: "Work"
-};
-const SUCCESS_EXIT_CODE = 0;
-const USAGE_ERROR_EXIT_CODE = 2;
-const createPhaseStartedOutput = (phase, durationMs) => {
-	const durationMinutes = durationMs / MILLISECONDS_PER_MINUTE;
-	return `${PHASE_ICONS[phase]} ${PHASE_NAMES[phase]} started (${durationMinutes} min)\n`;
-};
-const emitDiagnostic = (writeError, message) => {
-	try {
-		writeError(message);
-	} catch {}
-};
-const emitStandardOutput = (output) => {
-	process$1.stdout.write(output);
-};
-const runCli = async ({ arguments_ = process$1.argv.slice(CLI_ARGUMENTS_START_INDEX), confirmStart = confirmWorkStart, playSound = playCompletionSound, wait, writeError = createDiagnosticWriter(), writeOutput = emitStandardOutput } = {}) => {
-	const parsedArguments = parseCliArguments(arguments_);
-	if (parsedArguments.kind === "error") {
-		emitDiagnostic(writeError, parsedArguments.message);
-		return USAGE_ERROR_EXIT_CODE;
-	}
-	if (parsedArguments.kind === "help") {
-		writeOutput(createCliOutput({
-			optionName: "--help",
-			options: OPTIONS
-		}));
-		return SUCCESS_EXIT_CODE;
-	}
-	writeOutput(createCliOutput({
-		optionName: "",
-		options: OPTIONS
-	}));
-	if (!await confirmStart()) {
-		writeOutput("⏹️ Work was not started.\n");
-		return SUCCESS_EXIT_CODE;
-	}
-	for (let cycleIndex = 0; cycleIndex < parsedArguments.loopCount; cycleIndex += COUNT_INCREMENT) await runPomodoroCycle({
-		breakDurationMs: parsedArguments.breakDurationMinutes * MILLISECONDS_PER_MINUTE,
-		onPhaseCompleted: (phase) => {
-			writeOutput(`✅ ${PHASE_NAMES[phase]} complete.\n`);
-			playSound(phase);
-		},
-		onPhaseStarted: (phase, durationMs) => writeOutput(createPhaseStartedOutput(phase, durationMs)),
-		wait,
-		workDurationMs: parsedArguments.workDurationMinutes * MILLISECONDS_PER_MINUTE
-	});
-	writeOutput("🎉 Pomodoro complete.\n");
-	return SUCCESS_EXIT_CODE;
-};
-//#endregion
-//#region src/cli.ts
-const FAILURE_EXIT_CODE = 1;
-const handleFailure = (error) => {
-	process$1.exitCode = FAILURE_EXIT_CODE;
-	process$1.stderr.write(`${String(error)}\n`);
-};
-try {
-	process$1.exitCode = await runCli();
-} catch (error) {
-	handleFailure(error);
-}
-//#endregion
-export {};