Implement Context Keys & Conditional Keybinds

src/schemas/keyBindingSchema.ts

@@ -17,7 +17,8 @@ export const zKeybinding = z.object({
   // Note: Currently only used to distinguish between global keybindings
   // and litegraph canvas keybindings.
   // Do NOT use this field in extensions as it has no effect.
-  targetElementId: z.string().optional()
+  targetElementId: z.string().optional(),
+  condition: z.string().optional()
 })
 
 // Infer types from schemas

src/services/keybindingService.ts

@@ -1,5 +1,6 @@
 import { CORE_KEYBINDINGS } from '@/constants/coreKeybindings'
 import { useCommandStore } from '@/stores/commandStore'
+import { useContextKeyStore } from '@/stores/contextKeyStore'
 import {
   KeyComboImpl,
   KeybindingImpl,
@@ -11,6 +12,7 @@ export const useKeybindingService = () => {
   const keybindingStore = useKeybindingStore()
   const commandStore = useCommandStore()
   const settingStore = useSettingStore()
+  const contextKeyStore = useContextKeyStore()
 
   const keybindHandler = async function (event: KeyboardEvent) {
     const keyCombo = KeyComboImpl.fromEvent(event)
@@ -32,6 +34,14 @@ export const useKeybindingService = () => {
 
     const keybinding = keybindingStore.getKeybinding(keyCombo)
     if (keybinding && keybinding.targetElementId !== 'graph-canvas') {
+      // If condition exists and evaluates to false
+      // TODO: Complex context key evaluation
+      if (
+        keybinding.condition &&
+        contextKeyStore.evaluateCondition(keybinding.condition) !== true
+      ) {
+        return
+      }
       // Prevent default browser behavior first, then execute the command
       event.preventDefault()
       await commandStore.execute(keybinding.commandId)

src/stores/contextKeyStore.ts

@@ -0,0 +1,63 @@
+import { get, set, unset } from 'lodash'
+import { defineStore } from 'pinia'
+import { reactive } from 'vue'
+
+import { ContextValue, evaluateExpression } from '@/utils/expressionParserUtil'
+
+export const useContextKeyStore = defineStore('contextKeys', () => {
+  const contextKeys = reactive<Record<string, ContextValue>>({})
+
+  /**
+   * Get a stored context key by path.
+   * @param {string} path - The dot-separated path to the context key (e.g., 'a.b.c').
+   * @returns {ContextValue | undefined} The value of the context key, or undefined if not found.
+   */
+  function getContextKey(path: string): ContextValue | undefined {
+    return get(contextKeys, path)
+  }
+
+  /**
+   * Set or update a context key value at a given path.
+   * @param {string} path - The dot-separated path to the context key (e.g., 'a.b.c').
+   * @param {ContextValue} value - The value to set for the context key.
+   */
+  function setContextKey(path: string, value: ContextValue) {
+    set(contextKeys, path, value)
+  }
+
+  /**
+   * Remove a context key by path.
+   * @param {string} path - The dot-separated path to the context key to remove (e.g., 'a.b.c').
+   */
+  function removeContextKey(path: string) {
+    unset(contextKeys, path)
+  }
+
+  /**
+   * Clear all context keys from the store.
+   */
+  function clearAllContextKeys() {
+    for (const key in contextKeys) {
+      delete contextKeys[key]
+    }
+  }
+
+  /**
+   * Evaluates a context key expression string using the current context keys.
+   * Returns false if the expression is invalid or if any referenced key is undefined.
+   * @param {string} expr - The expression string to evaluate (e.g., "key1 && !key2 || (key3 == 'type2')").
+   * @returns {boolean} The result of the expression evaluation. Returns false if the expression is invalid.
+   */
+  function evaluateCondition(expr: string): boolean {
+    return evaluateExpression(expr, getContextKey)
+  }
+
+  return {
+    contextKeys,
+    getContextKey,
+    setContextKey,
+    removeContextKey,
+    clearAllContextKeys,
+    evaluateCondition
+  }
+})

src/stores/keybindingStore.ts

@@ -9,11 +9,13 @@ export class KeybindingImpl implements Keybinding {
   commandId: string
   combo: KeyComboImpl
   targetElementId?: string
+  condition?: string
 
   constructor(obj: Keybinding) {
     this.commandId = obj.commandId
     this.combo = new KeyComboImpl(obj.combo)
     this.targetElementId = obj.targetElementId
+    this.condition = obj.condition
   }
 
   equals(other: unknown): boolean {
@@ -22,7 +24,8 @@ export class KeybindingImpl implements Keybinding {
     return raw instanceof KeybindingImpl
       ? this.commandId === raw.commandId &&
           this.combo.equals(raw.combo) &&
-          this.targetElementId === raw.targetElementId
+          this.targetElementId === raw.targetElementId &&
+          this.condition === raw.condition
       : false
   }
 }