wp-typia 0.16.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wp-typia",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Canonical CLI package for wp-typia scaffolding and project workflows",
   "packageManager": "bun@1.3.11",
   "type": "module",

package/src/ui/README.md

@@ -15,3 +15,10 @@ Constraints:
   shell automation.
 - `@wp-typia/project-tools` remains the runtime library; these screens should only
   collect input and hand the resolved command state back to `wp-typia`.
+
+Alternate-buffer lifecycle contract:
+
+- `LazyFlow` owns pre-mount lifecycle safety for lazy loader failures and loading-time quit.
+- Mounted flows must use the shared alternate-buffer lifecycle helper instead of ad hoc exit logic.
+- `create`, `add`, and `migrate` must always call `runtime.exit()` on submit success, cancel, and quit.
+- Runtime execution failures use exit-on-failure: report the error, then exit immediately.

package/src/ui/add-flow.tsx

@@ -1,11 +1,9 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { HOOKED_BLOCK_POSITION_IDS } from "@wp-typia/project-tools";
 import { z } from "zod";
 
 import { executeAddCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const addFlowSchema = z.object({
 	anchor: z.string().optional(),
@@ -41,16 +39,11 @@ const HOOKED_BLOCK_POSITION_DESCRIPTIONS: Record<
 };
 
 export function AddFlow({ cwd, initialValues, workspaceBlockOptions }: AddFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia add failed");
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert message={errorMessage} title="Add failed" tone="danger" />
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{
 						kind: "select",
 						label: "Kind",
@@ -195,25 +188,20 @@ export function AddFlow({ cwd, initialValues, workspaceBlockOptions }: AddFlowPr
 							(values.template === "persistence" || values.template === "compound"),
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeAddCommand({
 							cwd,
 							flags: values,
 							kind: values.kind,
 							name: values.name,
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={addFlowSchema}
-				title="Extend a wp-typia workspace"
-			/>
-		</>
+				})
+			}
+			schema={addFlowSchema}
+			title="Extend a wp-typia workspace"
+		/>
 	);
 }

package/src/ui/alternate-buffer-lifecycle.ts

@@ -0,0 +1,152 @@
+import { useCallback } from "react";
+
+import { useRuntime } from "@bunli/runtime/app";
+import { useKeyboard } from "@bunli/tui";
+
+type AlternateBufferKeyEvent = {
+	ctrl?: boolean;
+	name?: string;
+};
+
+type AlternateBufferFailureOptions = {
+	context: string;
+	error: unknown;
+	exit: () => void;
+	log?: (message: string) => void;
+};
+
+type RunAlternateBufferActionOptions = {
+	action: () => Promise<void>;
+	context: string;
+	exit: () => void;
+	log?: (message: string) => void;
+};
+
+export function describeAlternateBufferFailure(context: string, error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error);
+	return `${context}: ${message}`;
+}
+
+export function isAlternateBufferExitKey(key: AlternateBufferKeyEvent): boolean {
+	return key.name === "q" || (key.ctrl === true && key.name === "c");
+}
+
+export function reportAlternateBufferFailure({
+	context,
+	error,
+	exit,
+	log = console.error,
+}: AlternateBufferFailureOptions): void {
+	const message = describeAlternateBufferFailure(context, error);
+	exit();
+	log(message);
+}
+
+export async function runAlternateBufferAction({
+	action,
+	context,
+	exit,
+	log = console.error,
+}: RunAlternateBufferActionOptions): Promise<void> {
+	try {
+		await action();
+		exit();
+	} catch (error) {
+		reportAlternateBufferFailure({ context, error, exit, log });
+	}
+}
+
+export async function resolveLazyFlowComponent<TProps>({
+	loader,
+	onLoaded,
+	onFailure,
+	isDisposed,
+}: {
+	loader: () => Promise<{ default: React.ComponentType<TProps> }>;
+	onLoaded: (component: React.ComponentType<TProps>) => void;
+	onFailure: (error: unknown) => void;
+	isDisposed: () => boolean;
+}): Promise<void> {
+	try {
+		const module = await loader();
+		if (!isDisposed()) {
+			onLoaded(module.default);
+		}
+	} catch (error) {
+		if (!isDisposed()) {
+			onFailure(error);
+		}
+	}
+}
+
+export function useAlternateBufferExitKeys(options: {
+	enabled?: boolean;
+	exit?: () => void;
+} = {}): void {
+	const runtime = useRuntime();
+	const exit = options.exit ?? (() => runtime.exit());
+	const enabled = options.enabled ?? true;
+
+	useKeyboard((key: AlternateBufferKeyEvent) => {
+		if (!enabled) {
+			return;
+		}
+
+		if (isAlternateBufferExitKey(key)) {
+			exit();
+		}
+	});
+}
+
+export function useAlternateBufferLifecycle(
+	context: string,
+	options: {
+		enableExitKeys?: boolean;
+	} = {},
+): {
+	handleCancel: () => void;
+	handleFailure: (error: unknown) => void;
+	handleSubmit: (action: () => Promise<void>) => Promise<void>;
+} {
+	const runtime = useRuntime();
+	const exit = useCallback(() => {
+		runtime.exit();
+	}, [runtime]);
+
+	useAlternateBufferExitKeys({
+		enabled: options.enableExitKeys ?? true,
+		exit,
+	});
+
+	const handleCancel = useCallback(() => {
+		exit();
+	}, [exit]);
+
+	const handleFailure = useCallback(
+		(error: unknown) => {
+			reportAlternateBufferFailure({
+				context,
+				error,
+				exit,
+			});
+		},
+		[context, exit],
+	);
+
+	const handleSubmit = useCallback(
+		async (action: () => Promise<void>) => {
+			await runAlternateBufferAction({
+				action,
+				context,
+				exit,
+			});
+		},
+		[context, exit],
+	);
+
+	return {
+		handleCancel,
+		handleFailure,
+		handleSubmit,
+	};
+}

package/src/ui/create-flow.tsx

@@ -1,10 +1,8 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { z } from "zod";
 
 import { executeCreateCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const createFlowSchema = z.object({
 	"data-storage": z.string().optional(),
@@ -31,8 +29,7 @@ type CreateFlowProps = {
 };
 
 export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia create failed");
 	const defaultPrompt = {
 		close() {},
 		select<T extends string>(_message: string, options: Array<{ value: T }>, defaultValue = 1) {
@@ -45,16 +42,8 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 	};
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert
-					message={errorMessage}
-					title="Create failed"
-					tone="danger"
-				/>
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{ kind: "text", label: "Project directory", name: "project-dir", required: true },
 					{
 						kind: "select",
@@ -146,11 +135,10 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 						name: "with-migration-ui",
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeCreateCommand({
 							cwd,
 							flags: values,
@@ -158,14 +146,10 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 							projectDir: values["project-dir"],
 							prompt: defaultPrompt,
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={createFlowSchema}
-				title="Create a wp-typia project"
-			/>
-		</>
+				})
+			}
+			schema={createFlowSchema}
+			title="Create a wp-typia project"
+		/>
 	);
 }

package/src/ui/lazy-flow.tsx

@@ -1,5 +1,11 @@
 import { createElement, useEffect, useState, type ComponentType } from "react";
 
+import {
+	resolveLazyFlowComponent,
+	useAlternateBufferExitKeys,
+	useAlternateBufferLifecycle,
+} from "./alternate-buffer-lifecycle";
+
 type LazyFlowProps<TProps> = {
 	loader: () => Promise<{ default: ComponentType<TProps> }>;
 	props: TProps;
@@ -7,31 +13,30 @@ type LazyFlowProps<TProps> = {
 
 export function LazyFlow<TProps>({ loader, props }: LazyFlowProps<TProps>) {
 	const [Component, setComponent] = useState<ComponentType<TProps> | null>(null);
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleFailure } = useAlternateBufferLifecycle("wp-typia TUI flow failed", {
+		enableExitKeys: false,
+	});
+
+	useAlternateBufferExitKeys({
+		enabled: Component === null,
+	});
 
 	useEffect(() => {
 		let disposed = false;
 
-		void loader()
-			.then((module) => {
-				if (!disposed) {
-					setComponent(() => module.default);
-				}
-			})
-			.catch((error) => {
-				if (!disposed) {
-					setErrorMessage(error instanceof Error ? error.message : String(error));
-				}
-			});
+		void resolveLazyFlowComponent({
+			isDisposed: () => disposed,
+			loader,
+			onFailure: handleFailure,
+			onLoaded: (component) => {
+				setComponent(() => component);
+			},
+		});
 
 		return () => {
 			disposed = true;
 		};
-	}, [loader]);
-
-	if (errorMessage) {
-		return errorMessage;
-	}
+	}, [handleFailure, loader]);
 
 	if (!Component) {
 		return null;

package/src/ui/migrate-flow.tsx

@@ -1,10 +1,8 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { z } from "zod";
 
 import { executeMigrateCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const migrateFlowSchema = z.object({
 	all: z.boolean().default(false),
@@ -48,16 +46,11 @@ function sanitizeMigrateValues(values: MigrateFlowValues): Record<string, unknow
 }
 
 export function MigrateFlow({ cwd, initialValues }: MigrateFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia migrate failed");
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert message={errorMessage} title="Migrate failed" tone="danger" />
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{
 						kind: "select",
 						label: "Migration command",
@@ -164,24 +157,19 @@ export function MigrateFlow({ cwd, initialValues }: MigrateFlowProps) {
 						visibleWhen: (values) => values.command === "fuzz",
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeMigrateCommand({
 							command: values.command,
 							cwd,
 							flags: sanitizeMigrateValues(values),
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={migrateFlowSchema}
-				title="Run wp-typia migration workflows"
-			/>
-		</>
+				})
+			}
+			schema={migrateFlowSchema}
+			title="Run wp-typia migration workflows"
+		/>
 	);
 }