@tooee/choose 0.2.3 → 0.3.0

package/src/fuzzy.ts

@@ -1,28 +1,28 @@
-import { fuzzyMatchPositions } from "@tooee/fuzzy"
-import type { ChooseItem } from "./types.js"
+import { fuzzyMatchPositions } from "@tooee/fuzzy";
+import type { ChooseItem } from "./types.js";
 
 export interface FuzzyMatch {
-  item: ChooseItem
-  originalIndex: number
-  score: number
-  positions: number[]
+  item: ChooseItem;
+  originalIndex: number;
+  score: number;
+  positions: number[];
 }
 
-export function fuzzyFilter(items: ChooseItem[], query: string): FuzzyMatch[] {
+export const fuzzyFilter = function fuzzyFilter(items: ChooseItem[], query: string): FuzzyMatch[] {
   if (!query) {
-    return items.map((item, i) => ({ item, originalIndex: i, score: 0, positions: [] }))
+    return items.map((item, i) => ({ item, originalIndex: i, positions: [], score: 0 }));
   }
 
-  const results: FuzzyMatch[] = []
+  const results: FuzzyMatch[] = [];
 
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i]
-    const match = fuzzyMatchPositions(query, item.text)
+  for (let i = 0; i < items.length; i += 1) {
+    const item = items[i];
+    const match = fuzzyMatchPositions(query, item.text);
     if (match) {
-      results.push({ item, originalIndex: i, score: match.score, positions: match.positions })
+      results.push({ item, originalIndex: i, positions: match.positions, score: match.score });
     }
   }
 
-  results.sort((a, b) => b.score - a.score)
-  return results
-}
+  results.sort((a, b) => b.score - a.score);
+  return results;
+};

package/src/index.ts

@@ -1,16 +1,16 @@
-export { Choose } from "./Choose.js"
-export type { ChooseProps } from "./Choose.js"
-export { ChooseOverlay } from "./ChooseOverlay.js"
-export type { ChooseOverlayProps } from "./ChooseOverlay.js"
-export { ChoosePanel, buildChooseHints } from "./ChoosePanel.js"
-export type { ChoosePanelProps, ChoosePanelInset, ChoosePanelInsetValue } from "./ChoosePanel.js"
-export { ChooseFilter } from "./ChooseFilter.js"
-export type { ChooseFilterProps } from "./ChooseFilter.js"
-export { ChooseList } from "./ChooseList.js"
-export type { ChooseItemRenderContext, ChooseListProps } from "./ChooseList.js"
-export { ChooseHighlightedText } from "./ChooseHighlightedText.js"
-export type { ChooseHighlightedTextProps } from "./ChooseHighlightedText.js"
-export { useChoose } from "./use-choose.js"
+export { Choose } from "./choose.js";
+export type { ChooseProps } from "./choose.js";
+export { ChooseOverlay } from "./choose-overlay.js";
+export type { ChooseOverlayProps } from "./choose-overlay.js";
+export { ChoosePanel, buildChooseHints } from "./choose-panel.js";
+export type { ChoosePanelProps, ChoosePanelInset, ChoosePanelInsetValue } from "./choose-panel.js";
+export { ChooseFilter } from "./choose-filter.js";
+export type { ChooseFilterProps } from "./choose-filter.js";
+export { ChooseList } from "./choose-list.js";
+export type { ChooseItemRenderContext, ChooseListProps } from "./choose-list.js";
+export { ChooseHighlightedText } from "./choose-highlighted-text.js";
+export type { ChooseHighlightedTextProps } from "./choose-highlighted-text.js";
+export { useChoose } from "./use-choose.js";
 export type {
   ChooseCommandGroup,
   ChooseController,
@@ -18,25 +18,25 @@ export type {
   ChooseViewModel,
   UseChooseOptions,
   UseChooseResult,
-} from "./use-choose.js"
-export { useChooseDialog } from "./use-choose-dialog.js"
+} from "./use-choose.js";
+export { useChooseDialog } from "./use-choose-dialog.js";
 export type {
   ChooseDialogHandle,
   ChooseDialogItems,
   ChooseDialogOptions,
   ChooseDialogOptionsBase,
   ChooseDialogToItem,
-} from "./use-choose-dialog.js"
-export { loadChooseSource } from "./source.js"
-export { launch } from "./launch.js"
-export type { ChooseLaunchOptions } from "./launch.js"
-export { createStdinChooseProvider, createStaticProvider } from "./default-provider.js"
-export { fuzzyFilter } from "./fuzzy.js"
-export type { FuzzyMatch } from "./fuzzy.js"
+} from "./use-choose-dialog.js";
+export { loadChooseSource } from "./source.js";
+export { launch } from "./launch.js";
+export type { ChooseLaunchOptions } from "./launch.js";
+export { createStdinChooseProvider, createStaticProvider } from "./default-provider.js";
+export { fuzzyFilter } from "./fuzzy.js";
+export type { FuzzyMatch } from "./fuzzy.js";
 export type {
   ChooseItem,
   ChooseContentProvider,
   ChooseSource,
   ChooseResult,
   ChooseOptions,
-} from "./types.js"
+} from "./types.js";

package/src/launch.tsx

@@ -1,17 +1,19 @@
-import { runCliSession } from "@tooee/shell"
-import type { ActionDefinition } from "@tooee/commands"
-import { Choose } from "./Choose.js"
-import type { ChooseContentProvider, ChooseOptions, ChooseResult } from "./types.js"
+import { runCliSession } from "@tooee/shell";
+import type { ActionDefinition } from "@tooee/commands";
+import { Choose } from "./choose.js";
+import type { ChooseContentProvider, ChooseOptions, ChooseResult } from "./types.js";
 
 export interface ChooseLaunchOptions {
-  contentProvider: ChooseContentProvider
-  options?: ChooseOptions
-  actions?: ActionDefinition[]
+  contentProvider: ChooseContentProvider;
+  options?: ChooseOptions;
+  actions?: ActionDefinition[];
 }
 
-export async function launch(opts: ChooseLaunchOptions): Promise<ChooseResult | null> {
-  return runCliSession<ChooseResult>(
-    ({ resolve, cancel }) => (
+export const launch = async function launch(
+  opts: ChooseLaunchOptions,
+): Promise<ChooseResult | null> {
+  const result = await runCliSession<ChooseResult>(
+    ({ resolve, cancel }): React.ReactNode => (
       <Choose
         contentProvider={opts.contentProvider}
         options={opts.options}
@@ -25,5 +27,6 @@ export async function launch(opts: ChooseLaunchOptions): Promise<ChooseResult |
       provider: { initialMode: "insert" },
       stdinPolicy: "tty-if-piped",
     },
-  )
-}
+  );
+  return result;
+};

package/src/source.ts

@@ -1,12 +1,18 @@
-import type { ChooseItem, ChooseSource } from "./types.js"
+import type { ChooseItem, ChooseSource } from "./types.js";
 
 /** Resolve every public Choose source shape through one compatibility boundary. */
-export function loadChooseSource(source: ChooseSource): ChooseItem[] | Promise<ChooseItem[]> {
-  if (Array.isArray(source)) return source
-  if (typeof source === "function") return source()
-  return source.load()
-}
+export const loadChooseSource = function loadChooseSource(
+  source: ChooseSource,
+): ChooseItem[] | Promise<ChooseItem[]> {
+  if (Array.isArray(source)) {
+    return source;
+  }
+  if (typeof source === "function") {
+    return source();
+  }
+  return source.load();
+};
 
-export function chooseSourceError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error)
-}
+export const chooseSourceError = function chooseSourceError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+};

package/src/types.ts

@@ -1,28 +1,28 @@
 export interface ChooseItem {
-  text: string
-  value?: string
-  icon?: string
-  description?: string
+  text: string;
+  value?: string;
+  icon?: string;
+  description?: string;
 }
 
 export interface ChooseContentProvider {
-  load(): Promise<ChooseItem[]> | ChooseItem[]
+  load: () => Promise<ChooseItem[]> | ChooseItem[];
 }
 
 /** Any item source accepted by the shared chooser core. */
 export type ChooseSource =
   | ChooseItem[]
   | ChooseContentProvider
-  | (() => ChooseItem[] | Promise<ChooseItem[]>)
+  | (() => ChooseItem[] | Promise<ChooseItem[]>);
 
 export interface ChooseResult {
-  items: ChooseItem[]
+  items: ChooseItem[];
 }
 
 export interface ChooseOptions {
-  multi?: boolean
-  title?: string
-  prompt?: string
-  placeholder?: string
-  emptyMessage?: string
+  multi?: boolean;
+  title?: string;
+  prompt?: string;
+  placeholder?: string;
+  emptyMessage?: string;
 }

package/src/use-choose-dialog.tsx

@@ -1,10 +1,12 @@
-import { useEffect, useRef, type ReactNode } from "react"
-import type { ActionDefinition } from "@tooee/commands"
-import { useOverlay, type OverlayHandle } from "@tooee/overlays"
-import { ChooseOverlay } from "./ChooseOverlay.js"
-import type { ChooseListProps } from "./ChooseList.js"
-import type { ChoosePanelProps } from "./ChoosePanel.js"
-import type { ChooseItem, ChooseSource } from "./types.js"
+import { useEffect, useRef } from "react";
+import type { ReactNode } from "react";
+import type { ActionDefinition } from "@tooee/commands";
+import { useOverlay } from "@tooee/overlays";
+import type { OverlayHandle } from "@tooee/overlays";
+import { ChooseOverlay } from "./choose-overlay.js";
+import type { ChooseListProps } from "./choose-list.js";
+import type { ChoosePanelProps } from "./choose-panel.js";
+import type { ChooseItem, ChooseSource } from "./types.js";
 
 /**
  * Per-open unique overlay id. A module-level sequence guarantees that
@@ -12,30 +14,30 @@ import type { ChooseItem, ChooseSource } from "./types.js"
  * same process — never share an overlay id, so one dialog can never displace
  * another through same-id replacement.
  */
-let chooseDialogSequence = 0
+let chooseDialogSequence = 0;
 
 /** Typed item source: a fixed list, or a loader invoked when the dialog opens. */
-export type ChooseDialogItems<T> = readonly T[] | (() => readonly T[] | Promise<readonly T[]>)
+export type ChooseDialogItems<T> = readonly T[] | (() => readonly T[] | Promise<readonly T[]>);
 
 export interface ChooseDialogOptionsBase<T> {
-  items: ChooseDialogItems<T>
+  items: ChooseDialogItems<T>;
   /** Multi-select: Tab toggles, Enter submits the selection (default false). */
-  multi?: boolean
-  prompt?: string
-  placeholder?: string
-  emptyMessage?: string
+  multi?: boolean;
+  prompt?: string;
+  placeholder?: string;
+  emptyMessage?: string;
   /**
    * Extra commands registered on the dialog's own command surface. Handlers
    * may open further dialogs; the nested dialog suspends this one until it
    * settles.
    */
-  commands?: ActionDefinition[]
+  commands?: ActionDefinition[];
   /** Chrome pass-throughs (see ChooseOverlay). */
-  renderItem?: ChooseListProps["renderItem"]
-  hints?: ChoosePanelProps["hints"]
-  statusRight?: ReactNode
-  footer?: ReactNode
-  inset?: ChoosePanelProps["inset"]
+  renderItem?: ChooseListProps["renderItem"];
+  hints?: ChoosePanelProps["hints"];
+  statusRight?: ReactNode;
+  footer?: ReactNode;
+  inset?: ChoosePanelProps["inset"];
 }
 
 /**
@@ -45,9 +47,9 @@ export interface ChooseDialogOptionsBase<T> {
  */
 export type ChooseDialogToItem<T> = [T] extends [ChooseItem]
   ? { toItem?: (item: T) => ChooseItem }
-  : { toItem: (item: T) => ChooseItem }
+  : { toItem: (item: T) => ChooseItem };
 
-export type ChooseDialogOptions<T> = ChooseDialogOptionsBase<T> & ChooseDialogToItem<T>
+export type ChooseDialogOptions<T> = ChooseDialogOptionsBase<T> & ChooseDialogToItem<T>;
 
 export interface ChooseDialogHandle<T> {
   /**
@@ -57,8 +59,10 @@ export interface ChooseDialogHandle<T> {
    * resolves the confirmed item; multi-select resolves the toggled items
    * (falling back to the active item when nothing is toggled).
    */
-  open(options: ChooseDialogOptions<T> & { multi: true }): Promise<T[] | null>
-  open(options: ChooseDialogOptions<T> & { multi?: false }): Promise<T | null>
+  open: {
+    (options: ChooseDialogOptions<T> & { multi: true }): Promise<T[] | null>;
+    (options: ChooseDialogOptions<T> & { multi?: false }): Promise<T | null>;
+  };
 }
 
 /**
@@ -75,136 +79,161 @@ export interface ChooseDialogHandle<T> {
  * (`AppLayout` does this automatically; custom hosts render
  * `useCurrentOverlay()`).
  */
-export function useChooseDialog<T>(): ChooseDialogHandle<T> {
-  const overlay = useOverlay()
-  const overlayRef = useRef(overlay)
-  overlayRef.current = overlay
+export const useChooseDialog = function useChooseDialog<T>(): ChooseDialogHandle<T> {
+  const overlay = useOverlay();
+  const overlayRef = useRef(overlay);
+  overlayRef.current = overlay;
 
   // Open dialogs by overlay id, so unmounting the owner closes (and thereby
   // settles) every dialog it opened.
-  const openHandlesRef = useRef(new Map<string, OverlayHandle<undefined>>())
-  const unmountedRef = useRef(false)
+  const openHandlesRef = useRef(new Map<string, OverlayHandle<undefined>>());
+  const unmountedRef = useRef(false);
 
   useEffect(() => {
-    unmountedRef.current = false
-    const handles = openHandlesRef.current
+    unmountedRef.current = false;
+    const handles = openHandlesRef.current;
     return () => {
-      unmountedRef.current = true
+      unmountedRef.current = true;
       // Map iteration tolerates deletion: settle() removes entries as each
       // close lands.
-      for (const handle of handles.values()) handle.close("unmounted")
-      handles.clear()
-    }
-  }, [])
+      for (const handle of handles.values()) {
+        handle.close("unmounted");
+      }
+      handles.clear();
+    };
+  }, []);
 
   // Stable identity so command handlers and effects can capture the handle.
-  const handleRef = useRef<ChooseDialogHandle<T> | null>(null)
+  const handleRef = useRef<ChooseDialogHandle<T> | null>(null);
   if (handleRef.current === null) {
-    const open = (
+    const open = async (
       options: ChooseDialogOptionsBase<T> & { toItem?: (item: T) => ChooseItem },
     ): Promise<T | T[] | null> => {
-      return new Promise<T | T[] | null>((resolvePromise) => {
-        if (unmountedRef.current) {
-          resolvePromise(null)
-          return
+      const { promise, resolve } = Promise.withResolvers<T | T[] | null>();
+      if (unmountedRef.current) {
+        resolve(null);
+        return null;
+      }
+
+      chooseDialogSequence += 1;
+      const id = `choose-dialog-${chooseDialogSequence}`;
+      let settled = false;
+      const settle = (value: T | T[] | null) => {
+        if (settled) {
+          return;
         }
-
-        const id = `choose-dialog-${++chooseDialogSequence}`
-        let settled = false
-        const settle = (value: T | T[] | null) => {
-          if (settled) return
-          settled = true
-          openHandlesRef.current.delete(id)
-          resolvePromise(value)
-        }
-
-        // Displayed rows map back to typed items by identity: every mapped
-        // row is a fresh object (spread copy), so duplicates in `items` and
-        // `toItem` results that share references stay unambiguous.
-        // Safe default: `toItem` may only be omitted when T is a ChooseItem
-        // (enforced by ChooseDialogToItem).
-        const toItem = options.toItem ?? ((item: T) => item as unknown as ChooseItem)
-        const rowToValue = new Map<ChooseItem, T>()
-        const mapValues = (values: readonly T[]): ChooseItem[] => {
-          rowToValue.clear()
-          return values.map((value) => {
-            const row = { ...toItem(value) }
-            rowToValue.set(row, value)
-            return row
-          })
-        }
-
-        // Created once per open() so the source identity is stable across
-        // overlay re-renders (a fresh source each render would reload forever).
-        const items = options.items
-        const source: ChooseSource = Array.isArray(items)
-          ? mapValues(items as readonly T[])
-          : () => {
-              const loaded = (items as () => readonly T[] | Promise<readonly T[]>)()
-              return loaded instanceof Promise ? loaded.then(mapValues) : mapValues(loaded)
+        settled = true;
+        openHandlesRef.current.delete(id);
+        resolve(value);
+      };
+
+      // Displayed rows map back to typed items by identity: every mapped
+      // row is a fresh object (spread copy), so duplicates in `items` and
+      // `toItem` results that share references stay unambiguous.
+      // Safe default: `toItem` may only be omitted when T is a ChooseItem
+      // (enforced by ChooseDialogToItem).
+      // Deferred(lint-sweep): replace the conditional generic API boundary with schema-safe overload implementation typing.
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- default mapper is enforced by ChooseDialogToItem's public type
+      const toItem = options.toItem ?? ((item: T) => item as unknown as ChooseItem);
+      const rowToValue = new Map<ChooseItem, T>();
+      const mapValues = (values: readonly T[]): ChooseItem[] => {
+        rowToValue.clear();
+        return values.map((value) => {
+          const row = { ...toItem(value) };
+          rowToValue.set(row, value);
+          return row;
+        });
+      };
+
+      // Created once per open() so the source identity is stable across
+      // overlay re-renders (a fresh source each render would reload forever).
+      const { items } = options;
+      const source: ChooseSource = Array.isArray(items)
+        ? mapValues(items as readonly T[])
+        : (): ChooseItem[] | Promise<ChooseItem[]> => {
+            // Deferred(lint-sweep): replace the conditional generic API boundary with schema-safe overload implementation typing.
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- implementation narrows the public source union after the branch
+            const loaded = (items as () => readonly T[] | Promise<readonly T[]>)();
+            if (loaded instanceof Promise) {
+              return (async () => mapValues(await loaded))();
             }
-
-        const multi = options.multi === true
-        const shared = {
-          items: source,
-          prompt: options.prompt,
-          placeholder: options.placeholder,
-          emptyMessage: options.emptyMessage,
-          commands: options.commands,
-          renderItem: options.renderItem,
-          hints: options.hints,
-          statusRight: options.statusRight,
-          footer: options.footer,
-          inset: options.inset,
-        }
-
-        const handle = overlayRef.current.open(
-          id,
-          () =>
-            multi ? (
-              <ChooseOverlay
-                {...shared}
-                multi
-                onSubmit={(result) => {
-                  if (settled) return
-                  const values = result.items.flatMap((row) => {
-                    const value = rowToValue.get(row)
-                    return value === undefined ? [] : [value]
-                  })
-                  settle(values)
-                  handle.close("close")
-                }}
-                onCancel={() => handle.close("escape")}
-              />
-            ) : (
-              <ChooseOverlay
-                {...shared}
-                onSelect={(row) => {
-                  if (settled) return
-                  const value = rowToValue.get(row)
-                  settle(value === undefined ? null : value)
-                  handle.close("close")
-                }}
-                onCancel={() => handle.close("escape")}
-              />
-            ),
-          undefined,
-          {
-            ownCommands: true,
-            role: "modal",
-            surfaceMode: "insert",
-            // Single settlement funnel: every close path (cancel, escape,
-            // replacement, unmount, external closeTop) lands here. Select and
-            // submit settle first, making this a no-op.
-            onClose: () => settle(null),
+            return mapValues(loaded);
+          };
+
+      const multi = options.multi === true;
+      const shared = {
+        commands: options.commands,
+        emptyMessage: options.emptyMessage,
+        footer: options.footer,
+        hints: options.hints,
+        inset: options.inset,
+        items: source,
+        placeholder: options.placeholder,
+        prompt: options.prompt,
+        renderItem: options.renderItem,
+        statusRight: options.statusRight,
+      };
+
+      const handle = overlayRef.current.open(
+        id,
+        (): ReactNode =>
+          multi ? (
+            <ChooseOverlay
+              {...shared}
+              multi
+              onSubmit={(result) => {
+                if (settled) {
+                  return;
+                }
+                const values = result.items.flatMap((row) => {
+                  const value = rowToValue.get(row);
+                  return value === undefined ? [] : [value];
+                });
+                settle(values);
+                handle.close("close");
+              }}
+              onCancel={() => {
+                handle.close("escape");
+              }}
+            />
+          ) : (
+            <ChooseOverlay
+              {...shared}
+              onSelect={(row) => {
+                if (settled) {
+                  return;
+                }
+                const value = rowToValue.get(row);
+                settle(value ?? null);
+                handle.close("close");
+              }}
+              onCancel={() => {
+                handle.close("escape");
+              }}
+            />
+          ),
+        undefined,
+        {
+          // Single settlement funnel: every close path (cancel, escape,
+          // replacement, unmount, external closeTop) lands here. Select and
+          // submit settle first, making this a no-op.
+          onClose: () => {
+            settle(null);
           },
-        )
-        openHandlesRef.current.set(id, handle)
-      })
-    }
-
-    handleRef.current = { open: open as ChooseDialogHandle<T>["open"] }
+          ownCommands: true,
+          role: "modal",
+          surfaceMode: "insert",
+        },
+      );
+      openHandlesRef.current.set(id, handle);
+      const result = await promise;
+      return result;
+    };
+
+    // Deferred(lint-sweep): replace the conditional generic API boundary with schema-safe overload implementation typing.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- implementation preserves the public overloaded handle contract
+    handleRef.current = { open: open as ChooseDialogHandle<T>["open"] };
   }
 
-  return handleRef.current
-}
+  return handleRef.current;
+};