feat: added ability to save prompt choices

Author: jakobrosenberg

package.json

@@ -264,12 +264,12 @@
         }
       },
       {
-        "title": "Notifications",
+        "title": "Misc",
         "properties": {
-          "pymakr.notifications.showSharedTerminalInfo": {
-            "type": "boolean",
-            "default": true,
-            "description": "Show notification when a shared terminal is created."
+          "pymakr.misc.notifications": {
+            "description": "Stored choices for Pymakr notifications. To undo a choice, simply delete the entry.",
+            "type": "object",
+            "additionalProperties": "/.+/"
           }
         }
       }

src/utils/Notifier.js

@@ -3,66 +3,117 @@ const vscode = require("vscode");
 /**
  * @typedef {string} btnText selecting this option will not hide the notification in the future
  * @typedef {string} saveAsDefaultBtnTxt selecting this option will hide the notification in the future
+ * @typedef {Object.<string, btnText|[btnText, saveAsDefaultBtnTxt]>} Options
  */
 
+/**
+ * The Notifier class handles notifications, warnings and errors sent to the user.
+ * Use this.createNotification() for sending a notification.
+ */
 class Notifier {
   /** @param {PyMakr} pymakr */
   constructor(pymakr) {
     this.pymakr = pymakr;
+    this.DONT_ASK_AGAIN = "No and don't ask again";
+    this.DONT_SHOW_AGAIN = "Don't show again";
+    this.messagers = {
+      info: vscode.window.showInformationMessage,
+      warning: vscode.window.showWarningMessage,
+      error: vscode.window.showErrorMessage,
+    };
   }
 
   /**
+   * Creates VSCode notification, warning or error.
    * @example
    * createNotification(
    *   'warning', // info, warning or error
    *   'something happened', // the message
    *   // buttons, the key is the return value
    *   {
    *     optA: 'Use Option A',
-   *     // to make an option defaultable, use an array and provide the default as the second entry
+   *     // to make an option persistable, use an array and provide the persisted value as the second entry
    *     optB: ['Use option B', 'Always use option B']
    *   }
    * )
-   * @template {Object.<string, btnText|[btnText, saveAsDefaultBtnTxt]>} Buttons
+   * @template {Options} Buttons
    * @param {'info'|'warning'|'error'} type
-   * @param {string} message
-   * @param  {Buttons=} options
-   * @param {Boolean=} disableable
-   * @param {string=} id
-   * @returns {Promise<keyof Buttons|'disabled'>}
+   * @param {string} message // the message shown to the user
+   * @param  {Buttons=} options // map of {key: choice} or {key: [choice, persistent choice]}
+   * @param {Boolean=} rememberable // if true, a subsequent notification will ask if the choice should be saved for future prompts
+   * @param {string=} id // if not set, the notification message will be used
+   * @returns {Promise<keyof Buttons>}
    */
-  async createNotification(type, message, options, disableable, id) {
-    id = id || message;
-    const storedValue = this.pymakr.config.get().get(`notifications.${id}`);
-    if (storedValue) return storedValue;
+  async createNotification(type, message, options, rememberable, id) {
+    // Stale devices have question marks after stale values. We don't want these to cause duplicates
+    id = id || message.replace(/\?/g, "");
+    const storedValue = this.pymakr.config.get().get(`misc.notifications`)[id];
+    const messager = this.messagers[type];
+
+    const textToKeyMap = Object.entries(options).reduce((acc, [key, arr]) => {
+      [arr].flat().forEach((val) => (acc[val] = key));
+      return acc;
+    }, {});
 
-    const nativeOptions = disableable ? { disabled: [false, "Don't show again"] } : {};
-    const allOptions = { ...options, ...nativeOptions };
+    // if we have a stored choice, return it - except for a DONT_ASK_AGAIN value
+    if (storedValue && storedValue !== this.DONT_ASK_AGAIN) return textToKeyMap[storedValue];
 
+    const choice = await messager(message, ...Object.values(options).flat().filter(Boolean));
+
+    const result = textToKeyMap[choice];
+
+    // store user's choice if wanted
+    this.handlePersistables(id, options, choice, rememberable);
+
+    return result;
+  }
+
+  /**
+   * Handles persistable logic. If a choice is a persistable it will be saved.
+   * If it is not persistable, but the prompt is rememberable and the user makes a selection the choice will be saved.
+   * @param {string} id
+   * @param {Options} options
+   * @param {string} choice
+   * @param {Boolean} rememberable
+   */
+  async handlePersistables(id, options, choice, rememberable) {
     // array of button texts whose values should be saved
-    const persistables = Object.values(allOptions)
+    const persistables = Object.values(options)
       .map((text) => Array.isArray(text) && text[1])
       .filter(Boolean);
 
-    const messagers = {
-      info: vscode.window.showInformationMessage,
-      warning: vscode.window.showWarningMessage,
-      error: vscode.window.showErrorMessage,
-    };
+    const shouldStoreChoice = persistables.includes(choice) || (rememberable && (await this.askToStore(choice)));
+    if (shouldStoreChoice === this.DONT_ASK_AGAIN) choice = this.DONT_ASK_AGAIN;
+    if (shouldStoreChoice) {
+      console.log("setting", `misc.notifications.${id}`, choice);
+      const config = this.pymakr.config.get().get("misc.notifications");
+      this.pymakr.config.get().update(`misc.notifications`, { ...config, [id]: choice });
+    }
+  }
 
-    const messager = messagers[type];
-    const result = await messager(message, ...Object.values(allOptions).flat().filter(Boolean));
+  /**
+   * Prompts user if they want their choice to be remembered
+   * @param {string} choice
+   */
+  async askToStore(choice) {
+    if (choice === undefined) return false;
 
-    if (persistables.includes(result)) console.log("should store this thing", result);
+    const options = {
+      Yes: true,
+      [this.DONT_ASK_AGAIN]: this.DONT_ASK_AGAIN,
+    };
 
-    const textToKeyMap = Object.entries(allOptions).reduce((acc, [key, arr]) => {
-      [arr].flat().forEach(val => acc[val] = key)
-      return acc;
-    }, {});
+    const shouldSaveChoice = await vscode.window.showInformationMessage(
+      `Do you wish to save your choice: "${choice}"`,
+      ...Object.keys(options)
+    );
 
-    return textToKeyMap[result]
+    return options[shouldSaveChoice];
   }
 
+  /**
+   * All available notifications in Pymakr
+   */
   notifications = {
     showSharedTerminalInfo: () =>
       this.createNotification(
@@ -77,16 +128,21 @@ class Notifier {
       this.createNotification(
         "info",
         `${device.displayName} seems to be busy. Do you wish restart it in safe mode?`,
-        { restart: "Restart in safe mode" },
+        { restart: "Restart in safe mode", [this.DONT_SHOW_AGAIN]: [null, this.DONT_SHOW_AGAIN] },
         true
       ),
 
     /** @param {Device} device */
     terminalAlreadyExists: (device) =>
-      this.createNotification("info", `A terminal for ${device.displayName} already exists.`, {
-        sharedTerm: ["Create new shared terminal", "Always create a shared terminal"],
-        openExistingTerm: ["Open existing terminal", "Always Open existing terminal"],
-      }),
+      this.createNotification(
+        "info",
+        `A terminal for ${device.displayName} already exists.`,
+        {
+          sharedTerm: "Create new shared terminal",
+          openExistingTerm: "Open existing terminal",
+        },
+        true
+      ),
 
     /** @param {Project} project */
     couldNotParsePymakrConfig: (project) =>
@@ -118,7 +174,8 @@ class Notifier {
     couldNotSafeboot: (device) =>
       this.createNotification(
         "warning",
-        "Could not safeboot device. Please hard reset the device and verify that a shield is installed."
+        "Could not safeboot device. Please hard reset the device and verify that a shield is installed.",
+        { [this.DONT_SHOW_AGAIN]: [null, this.DONT_SHOW_AGAIN] }
       ),
   };
 }