force boolean

Author: benceruleanlu

src/services/keybindingService.ts

@@ -38,7 +38,7 @@ export const useKeybindingService = () => {
       // TODO: Complex context key evaluation
       if (
         keybinding.condition &&
-        !contextKeyStore.getContextKey(keybinding.condition)
+        contextKeyStore.getContextKey(keybinding.condition) !== true
       ) {
         return
       }

src/stores/contextKeyStore.ts

@@ -2,14 +2,14 @@ import { defineStore } from 'pinia'
 import { reactive } from 'vue'
 
 export const useContextKeyStore = defineStore('contextKeys', () => {
-  const contextKeys = reactive<Record<string, any>>({})
+  const contextKeys = reactive<Record<string, boolean>>({})
 
   /**
    * Get a stored context key by path
    * @param {string} path - The path to the context key (e.g., 'a.b.c').
-   * @returns {any} The value of the context key, or undefined if not found.
+   * @returns {boolean|undefined} The value of the context key, or undefined if not found.
    */
-  function getContextKey(path: string): any {
+  function getContextKey(path: string): boolean | undefined {
     if (!path) return undefined
     const keys = path.split('.')
     let node: any = contextKeys
@@ -25,9 +25,9 @@ export const useContextKeyStore = defineStore('contextKeys', () => {
   /**
    * Set or update a context key value at a given path
    * @param {string} path - The path to the context key (e.g., 'a.b.c').
-   * @param {any} value - The value to set for the context key.
+   * @param {boolean} value - The value to set for the context key.
    */
-  function setContextKey(path: string, value: any) {
+  function setContextKey(path: string, value: boolean) {
     if (!path) return
     const keys = path.split('.')
     const last = keys.pop()!

tests-ui/tests/store/contextKeyStore.spec.ts

@@ -16,58 +16,58 @@ describe('useContextKeyStore', () => {
   describe('setContextKey', () => {
     it('sets a top-level key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('foo', 'bar')
-      expect(store.contextKeys).toEqual({ foo: 'bar' })
+      store.setContextKey('foo', true)
+      expect(store.contextKeys).toEqual({ foo: true })
     })
 
     it('sets a nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
-      expect(store.contextKeys).toEqual({ a: { b: { c: 123 } } })
+      store.setContextKey('a.b.c', true)
+      expect(store.contextKeys).toEqual({ a: { b: { c: true } } })
     })
 
     it('overwrites an existing key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('foo', 'bar')
-      store.setContextKey('foo', 'baz')
-      expect(store.contextKeys).toEqual({ foo: 'baz' })
+      store.setContextKey('foo', true)
+      store.setContextKey('foo', false)
+      expect(store.contextKeys).toEqual({ foo: false })
     })
 
     it('overwrites an existing nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
-      store.setContextKey('a.b.c', 456)
-      expect(store.contextKeys).toEqual({ a: { b: { c: 456 } } })
+      store.setContextKey('a.b.c', true)
+      store.setContextKey('a.b.c', false)
+      expect(store.contextKeys).toEqual({ a: { b: { c: false } } })
     })
 
     it('creates intermediate objects when setting nested keys', () => {
       const store = useContextKeyStore()
-      store.setContextKey('x.y', 'level2')
-      store.setContextKey('x.z', 'another level2')
+      store.setContextKey('x.y', true)
+      store.setContextKey('x.z', false)
       expect(store.contextKeys).toEqual({
-        x: { y: 'level2', z: 'another level2' }
+        x: { y: true, z: false }
       })
     })
 
     it('handles overwriting a non-object with an object for nested keys', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a', 1)
-      store.setContextKey('a.b', 'nested')
-      expect(store.contextKeys).toEqual({ a: { b: 'nested' } })
+      store.setContextKey('a', true)
+      store.setContextKey('a.b', false)
+      expect(store.contextKeys).toEqual({ a: { b: false } })
     })
   })
 
   describe('getContextKey', () => {
     it('gets a top-level key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('foo', 'bar')
-      expect(store.getContextKey('foo')).toBe('bar')
+      store.setContextKey('foo', true)
+      expect(store.getContextKey('foo')).toBe(true)
     })
 
     it('gets a nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
-      expect(store.getContextKey('a.b.c')).toBe(123)
+      store.setContextKey('a.b.c', true)
+      expect(store.getContextKey('a.b.c')).toBe(true)
     })
 
     it('returns undefined for a non-existent top-level key', () => {
@@ -77,53 +77,53 @@ describe('useContextKeyStore', () => {
 
     it('returns undefined for a non-existent nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b', {})
+      store.setContextKey('a.b', true)
       expect(store.getContextKey('a.b.c')).toBeUndefined()
     })
 
     it('returns undefined when path segment does not exist', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b', 1)
+      store.setContextKey('a.b', true)
       expect(store.getContextKey('a.x.c')).toBeUndefined()
     })
   })
 
   describe('removeContextKey', () => {
     it('removes a top-level key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('foo', 'bar')
-      store.setContextKey('baz', 'qux')
+      store.setContextKey('foo', true)
+      store.setContextKey('baz', false)
       store.removeContextKey('foo')
-      expect(store.contextKeys).toEqual({ baz: 'qux' })
+      expect(store.contextKeys).toEqual({ baz: false })
     })
 
     it('removes a nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
-      store.setContextKey('a.b.d', 456)
+      store.setContextKey('a.b.c', true)
+      store.setContextKey('a.b.d', false)
       store.removeContextKey('a.b.c')
-      expect(store.contextKeys).toEqual({ a: { b: { d: 456 } } })
+      expect(store.contextKeys).toEqual({ a: { b: { d: false } } })
     })
 
     it('prunes empty ancestor objects when removing a nested key', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
+      store.setContextKey('a.b.c', true)
       store.removeContextKey('a.b.c')
-      expect(store.contextKeys).toEqual({}) // a and a.b should be pruned
+      expect(store.contextKeys).toEqual({})
     })
 
     it('prunes only up to the non-empty ancestor', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b.c', 123)
-      store.setContextKey('a.x', 456) // Add another key under 'a'
+      store.setContextKey('a.b.c', true)
+      store.setContextKey('a.x', false)
       store.removeContextKey('a.b.c')
-      expect(store.contextKeys).toEqual({ a: { x: 456 } }) // a.b pruned, but a remains
+      expect(store.contextKeys).toEqual({ a: { x: false } })
     })
 
     it('does nothing if the key does not exist', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a.b', 1)
-      const initialState = JSON.parse(JSON.stringify(store.contextKeys)) // Deep clone
+      store.setContextKey('a.b', true)
+      const initialState = JSON.parse(JSON.stringify(store.contextKeys))
       store.removeContextKey('nonexistent')
       expect(store.contextKeys).toEqual(initialState)
       store.removeContextKey('a.c')
@@ -134,7 +134,7 @@ describe('useContextKeyStore', () => {
 
     it('does nothing if the path is empty', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a', 1)
+      store.setContextKey('a', true)
       const initialState = JSON.parse(JSON.stringify(store.contextKeys))
       store.removeContextKey('')
       expect(store.contextKeys).toEqual(initialState)
@@ -144,8 +144,8 @@ describe('useContextKeyStore', () => {
   describe('clearAllContextKeys', () => {
     it('clears all keys', () => {
       const store = useContextKeyStore()
-      store.setContextKey('a', 1)
-      store.setContextKey('b.c', 2)
+      store.setContextKey('a', true)
+      store.setContextKey('b.c', false)
       store.clearAllContextKeys()
       expect(store.contextKeys).toEqual({})
     })