feat: user prompts

app/store/prompt.ts

@@ -5,62 +5,74 @@ import { getLang } from "../locales";
 
 export interface Prompt {
   id?: number;
+  isUser?: boolean;
   title: string;
   content: string;
 }
 
 export interface PromptStore {
+  counter: number;
   latestId: number;
-  prompts: Map<number, Prompt>;
+  prompts: Record<number, Prompt>;
 
   add: (prompt: Prompt) => number;
   remove: (id: number) => void;
   search: (text: string) => Prompt[];
+
+  getUserPrompts: () => Prompt[];
+  updateUserPrompts: (id: number, updater: (prompt: Prompt) => void) => void;
 }
 
 export const PROMPT_KEY = "prompt-store";
 
 export const SearchService = {
   ready: false,
-  engine: new Fuse<Prompt>([], { keys: ["title"] }),
+  builtinEngine: new Fuse<Prompt>([], { keys: ["title"] }),
+  userEngine: new Fuse<Prompt>([], { keys: ["title"] }),
   count: {
     builtin: 0,
   },
-  allBuiltInPrompts: [] as Prompt[],
+  allPrompts: [] as Prompt[],
+  builtinPrompts: [] as Prompt[],
 
-  init(prompts: Prompt[]) {
+  init(builtinPrompts: Prompt[], userPrompts: Prompt[]) {
     if (this.ready) {
       return;
     }
-    this.allBuiltInPrompts = prompts;
-    this.engine.setCollection(prompts);
+    this.allPrompts = userPrompts.concat(builtinPrompts);
+    this.builtinPrompts = builtinPrompts.slice();
+    this.builtinEngine.setCollection(builtinPrompts);
+    this.userEngine.setCollection(userPrompts);
     this.ready = true;
   },
 
   remove(id: number) {
-    this.engine.remove((doc) => doc.id === id);
+    this.userEngine.remove((doc) => doc.id === id);
   },
 
   add(prompt: Prompt) {
-    this.engine.add(prompt);
+    this.userEngine.add(prompt);
   },
 
   search(text: string) {
-    const results = this.engine.search(text);
-    return results.map((v) => v.item);
+    const userResults = this.userEngine.search(text);
+    const builtinResults = this.builtinEngine.search(text);
+    return userResults.concat(builtinResults).map((v) => v.item);
   },
 };
 
 export const usePromptStore = create<PromptStore>()(
   persist(
     (set, get) => ({
+      counter: 0,
       latestId: 0,
-      prompts: new Map(),
+      prompts: {},
 
       add(prompt) {
         const prompts = get().prompts;
         prompt.id = get().latestId + 1;
-        prompts.set(prompt.id, prompt);
+        prompt.isUser = true;
+        prompts[prompt.id] = prompt;
 
         set(() => ({
           latestId: prompt.id!,
@@ -72,19 +84,40 @@ export const usePromptStore = create<PromptStore>()(
 
       remove(id) {
         const prompts = get().prompts;
-        prompts.delete(id);
+        delete prompts[id];
         SearchService.remove(id);
 
         set(() => ({
           prompts,
+          counter: get().counter + 1,
         }));
       },
 
+      getUserPrompts() {
+        const userPrompts = Object.values(get().prompts ?? {});
+        userPrompts.sort((a, b) => (b.id && a.id ? b.id - a.id : 0));
+        return userPrompts;
+      },
+
+      updateUserPrompts(id: number, updater) {
+        const prompt = get().prompts[id] ?? {
+          title: "",
+          content: "",
+          id,
+        };
+
+        SearchService.remove(id);
+        updater(prompt);
+        const prompts = get().prompts;
+        prompts[id] = prompt;
+        set(() => ({ prompts }));
+        SearchService.add(prompt);
+      },
+
       search(text) {
         if (text.length === 0) {
-          // return all prompts
-          const userPrompts = get().prompts?.values?.() ?? [];
-          return SearchService.allBuiltInPrompts.concat([...userPrompts]);
+          // return all rompts
+          return SearchService.allPrompts.concat([...get().getUserPrompts()]);
         }
         return SearchService.search(text) as Prompt[];
       },
@@ -104,23 +137,27 @@ export const usePromptStore = create<PromptStore>()(
             if (getLang() === "cn") {
               fetchPrompts = fetchPrompts.reverse();
             }
-            const builtinPrompts = fetchPrompts
-              .map((promptList: PromptList) => {
+            const builtinPrompts = fetchPrompts.map(
+              (promptList: PromptList) => {
                 return promptList.map(
                   ([title, content]) =>
                     ({
+                      id: Math.random(),
                       title,
                       content,
                     } as Prompt),
                 );
-              })
-              .concat([...(state?.prompts?.values() ?? [])]);
+              },
+            );
+
+            const userPrompts =
+              usePromptStore.getState().getUserPrompts() ?? [];
 
             const allPromptsForSearch = builtinPrompts
               .reduce((pre, cur) => pre.concat(cur), [])
               .filter((v) => !!v.title && !!v.content);
             SearchService.count.builtin = res.en.length + res.cn.length;
-            SearchService.init(allPromptsForSearch);
+            SearchService.init(allPromptsForSearch, userPrompts);
           });
       },
     },