fix: #117

rename: rule -> action
windingwind · Sep 15, 2023 · 320076e · 320076e
1 parent eb1d590
commit 320076e
Show file tree

Hide file tree

Showing 10 changed files with 186 additions and 171 deletions.
diff --git a/src/addon.ts b/src/addon.ts
@@ -1,7 +1,7 @@
 import { ProgressWindowHelper } from "zotero-plugin-toolkit/dist/helpers/progressWindow";
 import { VirtualizedTableHelper } from "zotero-plugin-toolkit/dist/helpers/virtualizedTable";
 import { createZToolkit } from "./utils/ztoolkit";
-import { TagRuleMap } from "./utils/rules";
+import { ActionMap } from "./utils/actions";
 import { KeyModifier } from "./utils/shorcut";
 import hooks from "./hooks";
 import api from "./api";
@@ -22,8 +22,8 @@ class Addon {
       editorWindow?: Window;
       editorInstance?: any;
     };
-    rules: {
-      data: TagRuleMap;
+    actions: {
+      map: ActionMap;
       cachedKeys: string[];
       selectedKey?: string;
     };
@@ -46,8 +46,8 @@ class Addon {
       env: __env__,
       ztoolkit: createZToolkit(),
       prefs: {},
-      rules: {
-        data: new Map(),
+      actions: {
+        map: new Map(),
         cachedKeys: [],
       },
       tabStatus: new Map(),

diff --git a/src/api.ts b/src/api.ts
@@ -1,7 +1,7 @@
 import {
-  dispatchRuleEvents,
-  dispatchRuleMenu,
-  dispatchRuleShortcuts,
+  dispatchEventAction,
+  dispatchMenuAction,
+  dispatchShortcutAction,
 } from "./modules/events";
 import { ClipboardHelper } from "zotero-plugin-toolkit/dist/helpers/clipboard";
 
@@ -10,8 +10,8 @@ const utils = {
 };
 
 export default {
-  dispatchRuleEvents,
-  dispatchRuleShortcuts,
-  dispatchRuleMenu,
+  dispatchEventAction,
+  dispatchShortcutAction,
+  dispatchMenuAction,
   utils,
 };
diff --git a/src/hooks.ts b/src/hooks.ts
@@ -1,7 +1,7 @@
 import { config, homepage } from "../package.json";
 import { getString, initLocale } from "./utils/locale";
 import { initPrefPane } from "./modules/preferenceWindow";
-import { TagEventTypes, initRules } from "./utils/rules";
+import { ActionEventTypes, initActions } from "./utils/actions";
 import { initNotifierObserver } from "./modules/notify";
 import { initShortcuts } from "./modules/shortcuts";
 import { buildItemMenu, initMenu } from "./modules/menu";
@@ -14,7 +14,7 @@ async function onStartup() {
   ]);
   initLocale();
 
-  initRules();
+  initActions();
 
   initNotifierObserver();
 
@@ -26,21 +26,21 @@ async function onStartup() {
     helpURL: homepage,
   });
 
-  await addon.api.dispatchRuleEvents(TagEventTypes.programStartup, {});
+  await addon.api.dispatchEventAction(ActionEventTypes.programStartup, {});
 
   await onMainWindowLoad(window);
 }
 
 async function onMainWindowLoad(win: Window): Promise<void> {
   initShortcuts(win);
   initMenu();
-  await addon.api.dispatchRuleEvents(TagEventTypes.mainWindowLoad, {
+  await addon.api.dispatchEventAction(ActionEventTypes.mainWindowLoad, {
     window: win,
   });
 }
 
 async function onMainWindowUnload(win: Window): Promise<void> {
-  await addon.api.dispatchRuleEvents(TagEventTypes.mainWindowUnload, {
+  await addon.api.dispatchEventAction(ActionEventTypes.mainWindowUnload, {
     window: win,
   });
 }

diff --git a/src/modules/events.ts b/src/modules/events.ts
@@ -1,41 +1,41 @@
-import { TagEventTypes, TagRuleData, applyRule } from "../utils/rules";
+import { ActionEventTypes, ActionDataData, applyAction } from "../utils/actions";
 import { KeyModifier } from "../utils/shorcut";
 
-export { dispatchRuleEvents, dispatchRuleShortcuts, dispatchRuleMenu };
+export { dispatchEventAction, dispatchShortcutAction, dispatchMenuAction };
 
-async function dispatchRuleEvents(eventType: TagEventTypes, data: TagRuleData) {
-  const rules = getRulesByEvent(eventType);
-  for (const rule of rules) {
-    await applyRule(rule, data);
+async function dispatchEventAction(eventType: ActionEventTypes, data: ActionDataData) {
+  const actions = getActionsByEvent(eventType);
+  for (const action of actions) {
+    await applyAction(action, data);
   }
 }
 
-function getRulesByEvent(event: TagEventTypes) {
-  return Array.from(addon.data.rules.data.values()).filter(
-    (rule) => rule.event === event && rule.enabled,
+function getActionsByEvent(event: ActionEventTypes) {
+  return Array.from(addon.data.actions.map.values()).filter(
+    (action) => action.event === event && action.enabled,
   );
 }
 
-async function dispatchRuleShortcuts(shortcut: KeyModifier, data: TagRuleData) {
-  const rules = getRulesByShortcuts(shortcut);
-  for (const rule of rules) {
-    await applyRule(rule, data);
+async function dispatchShortcutAction(shortcut: KeyModifier, data: ActionDataData) {
+  const actions = getActionsByShortcuts(shortcut);
+  for (const action of actions) {
+    await applyAction(action, data);
   }
 }
 
-function getRulesByShortcuts(shortcut: KeyModifier) {
-  return Array.from(addon.data.rules.data.values()).filter(
-    (rule) =>
-      rule.enabled &&
-      rule.shortcut &&
-      new KeyModifier(rule.shortcut).equals(shortcut),
+function getActionsByShortcuts(shortcut: KeyModifier) {
+  return Array.from(addon.data.actions.map.values()).filter(
+    (action) =>
+      action.enabled &&
+      action.shortcut &&
+      new KeyModifier(action.shortcut).equals(shortcut),
   );
 }
 
-async function dispatchRuleMenu(key: string, data: TagRuleData) {
-  const rule = addon.data.rules.data.get(key);
-  if (!rule) {
+async function dispatchMenuAction(key: string, data: ActionDataData) {
+  const action = addon.data.actions.map.get(key);
+  if (!action) {
     return;
   }
-  await applyRule(rule, data);
+  await applyAction(action, data);
 }
diff --git a/src/modules/menu.ts b/src/modules/menu.ts
@@ -32,7 +32,7 @@ function buildItemMenu(win: Window) {
   }
   // Add new children
   let elemProp: TagElementProps;
-  const enabledActions = getRulesByMenu();
+  const enabledActions = getActionsByMenu();
   if (enabledActions.length === 0) {
     elemProp = {
       tag: "menuitem",
@@ -45,17 +45,17 @@ function buildItemMenu(win: Window) {
     ztoolkit.UI.appendElement(
       {
         tag: "fragment",
-        children: enabledActions.map((rule) => {
+        children: enabledActions.map((action) => {
           return {
             tag: "menuitem",
             properties: {
-              label: rule.menu,
+              label: action.menu,
             },
             listeners: [
               {
                 type: "command",
                 listener: (event) => {
-                  triggerMenuCommand(rule.key);
+                  triggerMenuCommand(action.key);
                 },
               },
             ],
@@ -67,22 +67,22 @@ function buildItemMenu(win: Window) {
   }
 }
 
-function getRulesByMenu() {
-  return Array.from(addon.data.rules.data.keys())
+function getActionsByMenu() {
+  return Array.from(addon.data.actions.map.keys())
     .map((key) => {
-      const rule = addon.data.rules.data.get(key);
-      if (rule?.menu && rule?.enabled) {
-        return { key, menu: rule.menu };
+      const action = addon.data.actions.map.get(key);
+      if (action?.menu && action?.enabled) {
+        return { key, menu: action.menu };
       }
       return null;
     })
-    .filter((rule) => rule) as { key: string; menu: string }[];
+    .filter((action) => action) as { key: string; menu: string }[];
 }
 
 async function triggerMenuCommand(key: string) {
   const items = Zotero.getActiveZoteroPane().getSelectedItems();
   for (const item of items) {
-    await addon.api.dispatchRuleMenu(key, {
+    await addon.api.dispatchMenuAction(key, {
       itemID: item.id,
     });
   }

diff --git a/src/modules/notify.ts b/src/modules/notify.ts
@@ -1,4 +1,4 @@
-import { TagEventTypes } from "../utils/rules";
+import { ActionEventTypes } from "../utils/actions";
 import { recordTabStatus } from "./tabs";
 
 export { initNotifierObserver };
@@ -44,7 +44,7 @@ async function onNotify(
       Zotero.Items.get(ids as number[]),
     );
     for (const item of parentItems) {
-      await addon.api.dispatchRuleEvents(TagEventTypes.openFile, {
+      await addon.api.dispatchEventAction(ActionEventTypes.openFile, {
         itemID: item.id,
       });
     }
@@ -56,23 +56,23 @@ async function onNotify(
     );
     for (const item of items) {
       if (item.isRegularItem()) {
-        await addon.api.dispatchRuleEvents(TagEventTypes.createItem, {
+        await addon.api.dispatchEventAction(ActionEventTypes.createItem, {
           itemID: item.id,
         });
       } else if (item.isAnnotation()) {
-        await addon.api.dispatchRuleEvents(TagEventTypes.createAnnotation, {
+        await addon.api.dispatchEventAction(ActionEventTypes.createAnnotation, {
           itemID: item.id,
         });
         const parentItem = Zotero.Items.getTopLevel([item])[0];
-        await addon.api.dispatchRuleEvents(TagEventTypes.appendAnnotation, {
+        await addon.api.dispatchEventAction(ActionEventTypes.appendAnnotation, {
           itemID: parentItem.id,
         });
       } else if (item.isNote()) {
-        await addon.api.dispatchRuleEvents(TagEventTypes.createNote, {
+        await addon.api.dispatchEventAction(ActionEventTypes.createNote, {
           itemID: item.id,
         });
         const parentItem = Zotero.Items.getTopLevel([item])[0];
-        await addon.api.dispatchRuleEvents(TagEventTypes.appendNote, {
+        await addon.api.dispatchEventAction(ActionEventTypes.appendNote, {
           itemID: parentItem.id,
         });
       }
@@ -91,7 +91,7 @@ async function onNotify(
       Zotero.Items.get(itemIDs as number[]),
     );
     for (const item of parentItems) {
-      await addon.api.dispatchRuleEvents(TagEventTypes.closeTab, {
+      await addon.api.dispatchEventAction(ActionEventTypes.closeTab, {
         itemID: item.id,
       });
     }