Add FallSession command to manage picker sessions

Author: lambdalisue

autoload/fall/command/FallSession.vim

@@ -0,0 +1,11 @@
+function! fall#command#FallSession#call() abort
+  if denops#plugin#wait('fall') isnot# 0
+    return
+  endif
+  try
+    call fall#internal#picker#setup()
+    call denops#request('fall', 'picker:session:command', [])
+  finally
+    call fall#internal#picker#teardown()
+  endtry
+endfunction

denops/fall/extension/action/session.ts

@@ -0,0 +1,16 @@
+import type { Action } from "jsr:@vim-fall/core@^0.3.0/action";
+import type { Detail } from "../source/session.ts";
+
+export const defaultSessionActions = {
+  resume: {
+    invoke: async (denops, { item }) => {
+      if (!item) {
+        return;
+      }
+      // we need to use timer_start to avoid nesting pickers
+      await denops.cmd(
+        `call timer_start(0, { -> execute('FallResume ${item.value}') })`,
+      );
+    },
+  },
+} satisfies Record<string, Action<Detail>>;

denops/fall/extension/previewer/session.ts

@@ -0,0 +1,52 @@
+import type { PreviewItem } from "jsr:@vim-fall/core@^0.3.0/item";
+import type { Previewer } from "jsr:@vim-fall/core@^0.3.0/previewer";
+import { definePreviewer } from "jsr:@vim-fall/std@^0.10.0/previewer";
+import type { Detail } from "../source/session.ts";
+import { decompressPickerSession } from "../../session.ts";
+
+export function session(): Previewer<Detail> {
+  return definePreviewer(async (_denops, { item }, { signal }) => {
+    if (!item || signal?.aborted) {
+      return undefined;
+    }
+
+    try {
+      // Decompress the session to access its data
+      const session = await decompressPickerSession(item.detail);
+
+      const lines: string[] = [];
+
+      // Add session info
+      lines.push(`# Session: ${item.value}`);
+      lines.push("");
+      lines.push(`Source: ${session.name}`);
+      lines.push(`Query: ${session.context.query || "(empty)"}`);
+      lines.push(`Total items: ${session.context.collectedItems.length}`);
+      lines.push(`Filtered items: ${session.context.filteredItems.length}`);
+      lines.push("");
+      lines.push("## Filtered Items:");
+      lines.push("");
+
+      // Show filtered items with selection status
+      const selection = session.context.selection;
+      for (const filteredItem of session.context.filteredItems) {
+        const isSelected = selection.has(filteredItem.id);
+        const prefix = isSelected ? "[x]" : "[ ]";
+        lines.push(`${prefix} ${filteredItem.value}`);
+      }
+
+      if (session.context.filteredItems.length === 0) {
+        lines.push("(no items)");
+      }
+
+      return {
+        content: lines,
+        filetype: "markdown",
+      } satisfies PreviewItem;
+    } catch (error) {
+      return {
+        content: [`Error loading session preview: ${error}`],
+      } satisfies PreviewItem;
+    }
+  });
+}

denops/fall/extension/renderer/session.ts

@@ -0,0 +1,23 @@
+import type { Denops } from "jsr:@denops/std@^7.3.2";
+import type { Renderer } from "jsr:@vim-fall/core@^0.3.0/renderer";
+import type { DisplayItem } from "jsr:@vim-fall/core@^0.3.0/item";
+import type { Detail } from "../source/session.ts";
+
+export function session(): Renderer<Detail> {
+  return {
+    render(
+      _denops: Denops,
+      { items }: { items: DisplayItem<Detail>[] },
+      { signal }: { signal?: AbortSignal },
+    ): void {
+      for (const item of items) {
+        if (signal?.aborted) break;
+        item.label = [
+          item.value,
+          item.detail.name,
+          ...item.detail.args,
+        ].join(" ");
+      }
+    },
+  };
+}

denops/fall/extension/source/session.ts

@@ -0,0 +1,22 @@
+import type { Source } from "jsr:@vim-fall/core@^0.3.0/source";
+import type { DetailUnit, IdItem } from "jsr:@vim-fall/core@^0.3.0/item";
+import type { PickerSessionCompressed } from "../../session.ts";
+import { listPickerSessions } from "../../session.ts";
+
+export type Detail = PickerSessionCompressed<DetailUnit>;
+
+export function session(): Source<Detail> {
+  return {
+    collect: async function* (): AsyncIterableIterator<IdItem<Detail>> {
+      const sessions = listPickerSessions();
+      yield* sessions.map((session, index) => {
+        const number = index + 1;
+        return {
+          id: index,
+          value: `#${number}`,
+          detail: session,
+        };
+      });
+    },
+  };
+}

denops/fall/main/picker.ts

@@ -21,9 +21,19 @@ import {
   loadPickerSession,
   savePickerSession,
 } from "../session.ts";
+import type { Detail as SessionDetail } from "../extension/source/session.ts";
+import { session as sessionSource } from "../extension/source/session.ts";
+import { session as sessionRenderer } from "../extension/renderer/session.ts";
+import { session as sessionPreviewer } from "../extension/previewer/session.ts";
+import { defaultSessionActions } from "../extension/action/session.ts";
 
 let zindex = 50;
 
+const SESSION_EXCLUDE_SOURCES = [
+  "@action",
+  "@session",
+];
+
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
     ...denops.dispatcher,
@@ -74,6 +84,30 @@ export const main: Entrypoint = (denops) => {
         });
       },
     ),
+    "picker:session:command": withHandleError(denops, async () => {
+      await loadUserCustom(denops);
+      const { substring } = await import(
+        "jsr:@vim-fall/std@^0.10.0/builtin/matcher/substring"
+      );
+      const setting = getSetting();
+      const sessionPickerParams = {
+        name: "@session",
+        source: sessionSource(),
+        matchers: [substring()] as const,
+        sorters: [],
+        renderers: [sessionRenderer()],
+        previewers: [sessionPreviewer()],
+        actions: defaultSessionActions,
+        defaultAction: "resume",
+        ...setting,
+      } as PickerParams<SessionDetail, string>;
+      await startPicker(
+        denops,
+        [],
+        sessionPickerParams,
+        { signal: denops.interrupted },
+      );
+    }),
     "picker:resume:command:complete": withHandleError(
       denops,
       async (arglead, cmdline, cursorpos) => {
@@ -179,8 +213,12 @@ async function startPicker<T extends Detail>(
     zindex -= Picker.ZINDEX_ALLOCATION;
   });
   stack.defer(async () => {
+    const name = pickerParams.name;
+    if (SESSION_EXCLUDE_SOURCES.includes(name)) {
+      return;
+    }
     await savePickerSession({
-      name: pickerParams.name,
+      name,
       args,
       context: itemPicker.context,
     });

denops/fall/session.ts

@@ -51,10 +51,15 @@ async function compressPickerSession<T extends Detail>(
   session: PickerSession<T>,
 ): Promise<PickerSessionCompressed<T>> {
   const encoder = new TextEncoder();
+  // Convert Set to Array for JSON serialization
+  const contextForSerialization = {
+    ...session.context,
+    selection: Array.from(session.context.selection),
+  };
   return {
     ...session,
     context: await brotli.compress(
-      encoder.encode(JSON.stringify(session.context)),
+      encoder.encode(JSON.stringify(contextForSerialization)),
     ),
   };
 }
@@ -65,15 +70,20 @@ async function compressPickerSession<T extends Detail>(
  * @param compressed - The compressed session to decompress
  * @returns A promise that resolves to the decompressed session
  */
-async function decompressPickerSession<T extends Detail>(
+export async function decompressPickerSession<T extends Detail>(
   compressed: PickerSessionCompressed<T>,
 ): Promise<PickerSession<T>> {
   const decoder = new TextDecoder();
+  const decompressedContext = JSON.parse(
+    decoder.decode(await brotli.uncompress(compressed.context)),
+  );
+  // Convert selection array back to Set
   return {
     ...compressed,
-    context: JSON.parse(
-      decoder.decode(await brotli.uncompress(compressed.context)),
-    ),
+    context: {
+      ...decompressedContext,
+      selection: new Set(decompressedContext.selection),
+    },
   };
 }
 

denops/fall/session_test.ts

@@ -203,10 +203,8 @@ Deno.test("session management", async (t) => {
       assertEquals(loadedSession.context.previewerIndex, 4);
       assertEquals(loadedSession.context.collectedItems, testItems);
       assertEquals(loadedSession.context.filteredItems, testItems);
-      // Check that selection was preserved (Sets are converted to empty objects in JSON)
-      // The selection will be an empty object after deserialization since Set is not JSON serializable
-      assertEquals(typeof loadedSession.context.selection, "object");
-      assertEquals(loadedSession.context.selection, {} as unknown);
+      // Check that selection was preserved as a Set
+      assertEquals(loadedSession.context.selection, new Set(["test-1"]));
     },
   );
 
@@ -251,9 +249,8 @@ Deno.test("session management", async (t) => {
 
     assertExists(loaded);
     assertEquals(loaded.context.query, "");
-    // Selection will be deserialized as an empty object, not a Set
-    assertEquals(typeof loaded.context.selection, "object");
-    assertEquals(loaded.context.selection, {} as unknown);
+    // Selection will be deserialized as an empty Set
+    assertEquals(loaded.context.selection, new Set());
     assertEquals(loaded.context.collectedItems.length, 0);
     assertEquals(loaded.context.filteredItems.length, 0);
     assertEquals(loaded.context.cursor, 0);

doc/fall.txt

@@ -433,6 +433,28 @@ COMMAND						*fall-command*
 	:FallResume file#2
 <
 
+						*:FallSession*
+:FallSession
+	Open a picker to browse and resume previous picker sessions. Fall
+	automatically stores up to 100 picker sessions in memory, allowing
+	you to return to previous searches with their complete state including
+	query, filtered items, and selections.
+
+	Sessions are listed in reverse chronological order (newest first) and
+	display the session number, source name, and any arguments used.
+	Selecting a session resumes it with its exact state.
+
+	The following sources are excluded from session storage:
+	- "@action" (action selection picker)
+	- "@session" (the session picker itself)
+
+	Sessions are stored in compressed format to minimize memory usage.
+>
+	" Open the session picker
+	:FallSession
+<
+	See |:FallResume| for directly resuming sessions by number or source.
+
 						*:FallCustom*
 :FallCustom
 	Open "custom.ts" for customization. This TypeScript file exports a

plugin/fall.vim

@@ -8,6 +8,7 @@ command! -nargs=+ -complete=customlist,fall#command#Fall#complete
       \ Fall call fall#command#Fall#call([<f-args>])
 command! -nargs=? -complete=customlist,fall#command#FallResume#complete
       \ FallResume call fall#command#FallResume#call(<q-args>)
+command! -nargs=0 FallSession call fall#command#FallSession#call()
 
 command! -nargs=0 FallCustom call fall#command#FallCustom#call()
 command! -nargs=0 FallCustomReload call fall#command#FallCustomReload#call()