@witchcraft/spellcraft 0.1.0 → 0.2.0

package/dist/core/createManagerOptions.js

@@ -4,6 +4,7 @@ import { defaultSorter } from "../defaults/KeysSorter.js";
 import { defaultStringifier } from "../defaults/Stringifier.js";
 export function createManagerOptions(rawOpts) {
   const options = {
+    shortcutEqualityStrategy: "ignoreCommand",
     sorter: defaultSorter,
     stringifier: defaultStringifier,
     conditionEquals: defaultConditionEquals,

package/dist/core/createShortcuts.d.ts

@@ -6,7 +6,7 @@ import type { CanHookErrors, Manager, MultipleErrors, PickManager, Shortcut, Sho
  * Creates a set of shortcuts.
  *
  */
-export declare function createShortcuts<THooks extends Manager["hooks"], TRawShortcuts extends Shortcut[], TCheck extends boolean | "only" = true>(shortcutsList: TRawShortcuts, manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", "evaluateCondition" | "conditionEquals" | "stringifier" | "sorter"> & {
+export declare function createShortcuts<THooks extends Manager["hooks"], TRawShortcuts extends Shortcut[], TCheck extends boolean | "only" = true>(shortcutsList: TRawShortcuts, manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", "evaluateCondition" | "conditionEquals" | "stringifier" | "sorter" | "shortcutEqualityStrategy"> & {
     hooks?: THooks;
 }, opts?: Partial<Pick<Shortcuts, "ignoreModifierConflicts" | "ignoreChainConflicts">>, { check }?: {
     check?: boolean | "only";

package/dist/core/setShortcutsProp.js

@@ -20,7 +20,7 @@ export function setShortcutsProp(prop, val, manager, {
         castType(manager);
         const shortcut = val;
         const existing = shortcuts.entries.find(
-          (_) => equalsShortcut(shortcut, _, manager, { ignoreCommand: true }) || doesShortcutConflict(_, shortcut, manager)
+          (_) => equalsShortcut(shortcut, _, manager) || doesShortcutConflict(_, shortcut, manager)
         );
         if (existing) {
           return Err(new KnownError(
@@ -41,7 +41,7 @@ export function setShortcutsProp(prop, val, manager, {
       case "entries@remove": {
         const shortcut = val;
         const existing = shortcuts.entries.find(
-          (_) => _ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false })
+          (_) => _ === shortcut || equalsShortcut(shortcut, _, manager, { shortcutEqualityStrategy: "all" })
         );
         if (existing === void 0) {
           return Err(new KnownError(
@@ -77,7 +77,7 @@ export function setShortcutsProp(prop, val, manager, {
     }
     case "entries@remove": {
       const shortcut = val;
-      const i = shortcuts.entries.findIndex((_) => _ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false }));
+      const i = shortcuts.entries.findIndex((_) => _ === shortcut || equalsShortcut(shortcut, _, manager, { shortcutEqualityStrategy: "all" }));
       if (i < 0) {
         throw new Error("If used correctly, shortcut should exist at this point, but it does not.");
       }

package/dist/defaults/defaultConditionEquals.d.ts

@@ -1,19 +1,5 @@
 import type { Condition } from "../types/index.js";
 /**
- * Returns whether the condition passed is equal to this one.
- *
- * The default method does a simplistic object check, and otherwise a  check of the `text` property for equality. If both conditions are undefined, note this will return true.
- *
- * If you override the default conditionEquals option you will likely want it to just always return false.
- *
- * Why? Because unless you're using simple single variable conditions that you can presort to make them uniquely identifiable (i.e. not boolean expressions, e.g. `!a b !c`), this will return A LOT of false negatives.
- *
- * Why the false negatives? Because two conditions might be functionally equal but have differing representations (e.g: `a && b`, `b && a`). You might think, lets normalize them all, but normalizing boolean expressions (converting them to CNF) can be dangerous with very long expressions because it can take exponential time.
- *
- * Now the main reason for checking the equality of two conditions is to check if two shortcuts might conflict. If we're using boolean expressions it just can't be done safely.
- *
- * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
- *
- * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ * IMPORTANT: Please read {@link ConditionComparer} before using.
  */
-export declare function defaultConditionEquals<TCondition extends Condition>(conditionA?: TCondition, conditionB?: Condition): conditionB is TCondition;
+export declare function defaultConditionEquals<TCondition extends Condition>(conditionA: TCondition | undefined, conditionB: Condition | undefined, _type: "shortcut" | "command"): conditionB is TCondition;

package/dist/defaults/defaultConditionEquals.js

@@ -1,4 +1,4 @@
-export function defaultConditionEquals(conditionA, conditionB) {
+export function defaultConditionEquals(conditionA, conditionB, _type) {
   if (conditionA === conditionB) return true;
   if (!conditionA || !conditionB) return false;
   return conditionA.text === conditionB.text;

package/dist/helpers/doesShortcutConflict.d.ts

@@ -15,4 +15,4 @@ import type { Manager, PickManager, Shortcut } from "../types/index.js";
  */
 export declare function doesShortcutConflict<TShortcut extends Shortcut>(shortcutA: TShortcut, shortcutB: Shortcut, manager: Pick<Manager, "keys" | "commands" | "shortcuts"> & {
     context?: Manager["context"];
-} & PickManager<"options", "evaluateCondition" | "conditionEquals">): boolean;
+} & PickManager<"options", "evaluateCondition" | "conditionEquals" | "shortcutEqualityStrategy">): boolean;

package/dist/helpers/doesShortcutConflict.js

@@ -24,7 +24,7 @@ export function doesShortcutConflict(shortcutA, shortcutB, manager) {
       if (!shortcutCondition) return false;
     }
   } else {
-    if (!conditionEquals(shortcutA.condition, shortcutB.condition)) return false;
+    if (!conditionEquals(shortcutA.condition, shortcutB.condition, "shortcut")) return false;
   }
   const { keys } = manager;
   if (shortcutA.chain.length === 0 || shortcutB.chain.length === 0) {

package/dist/helpers/equalsCommand.js

@@ -1,4 +1,4 @@
 export function equalsCommand(commandA, commandB, manager) {
   if (commandA === commandB) return true;
-  return commandA.name === commandB.name && commandA.execute === commandB.execute && manager.options.conditionEquals(commandA.condition, commandB.condition) && commandA.description === commandB.description;
+  return commandA.name === commandB.name && commandA.execute === commandB.execute && manager.options.conditionEquals(commandA.condition, commandB.condition, "command") && commandA.description === commandB.description;
 }

package/dist/helpers/equalsShortcut.d.ts

@@ -2,8 +2,10 @@ import type { Manager, PickManager, Shortcut } from "../types/index.js";
 /**
  * Returns whether the shortcut passed is equal to shortcutA one.
  *
- * To return true, their keys and command must be equal (unless ignoreCommand is passed), their condition must be equal according to shortcutA shortcut's condition.
+ * To return true, their keys, conditions, and commands (depends on the configured `manager.options.shortcutEqualityStrategy`) must be equal.
+ *
+ * See {@link Manager.options.shortcutEqualityStrategy} for details.
+ *
+ * You can temporarily override the strategy witht the third parameter.
  */
-export declare function equalsShortcut<TShortcut extends Shortcut>(shortcutA: TShortcut, shortcutB: Shortcut, manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", "evaluateCondition" | "conditionEquals">, { ignoreCommand }?: {
-    ignoreCommand?: boolean;
-}): shortcutB is TShortcut;
+export declare function equalsShortcut<TShortcut extends Shortcut>(shortcutA: TShortcut, shortcutB: Shortcut, manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", "evaluateCondition" | "conditionEquals" | "shortcutEqualityStrategy">, overrides?: PickManager<"options", "shortcutEqualityStrategy">["options"]): shortcutB is TShortcut;

package/dist/helpers/equalsShortcut.js

@@ -1,7 +1,10 @@
 import { equalsCommand } from "./equalsCommand.js";
 import { equalsKeys } from "../utils/equalsKeys.js";
-export function equalsShortcut(shortcutA, shortcutB, manager, { ignoreCommand = false } = {}) {
+export function equalsShortcut(shortcutA, shortcutB, manager, overrides) {
   if (shortcutA.forceUnequal || shortcutB.forceUnequal) return false;
   if (shortcutA === shortcutB) return true;
-  return equalsKeys(shortcutA.chain, shortcutB.chain, manager.keys, void 0, { allowVariants: true }) && manager.options.conditionEquals(shortcutA.condition, shortcutB.condition) && (ignoreCommand || shortcutA.command === shortcutB.command && shortcutA.command === void 0 || shortcutA.command !== void 0 && shortcutB.command !== void 0 && equalsCommand(manager.commands.entries[shortcutA.command], manager.commands.entries[shortcutB.command], manager));
+  const commandA = shortcutA.command ? manager.commands.entries[shortcutA.command] : void 0;
+  const commandB = shortcutB.command ? manager.commands.entries[shortcutB.command] : void 0;
+  const shortcutEqualityStrategy = overrides?.shortcutEqualityStrategy ?? manager.options.shortcutEqualityStrategy;
+  return equalsKeys(shortcutA.chain, shortcutB.chain, manager.keys, void 0, { allowVariants: true }) && manager.options.conditionEquals(shortcutA.condition, shortcutB.condition, "shortcut") && (shortcutEqualityStrategy === "ignoreCommand" || shortcutEqualityStrategy === "ignoreCommandWithDifferentCondition" && commandA?.condition && commandB?.condition && manager.options.conditionEquals(commandA.condition, commandB.condition, "command") || shortcutA.command === shortcutB.command && shortcutA.command === void 0 || shortcutA.command !== void 0 && shortcutB.command !== void 0 && equalsCommand(manager.commands.entries[shortcutA.command], manager.commands.entries[shortcutB.command], manager));
 }

package/dist/helpers/getKeyCodesFromKeyIds.d.ts

@@ -0,0 +1,12 @@
+import { getKeyCodesFromKeys } from "./getKeyCodesFromKeys.js";
+import type { Keys } from "../types/keys.js";
+/**
+ * Given an list of key ids, returns an array of deduped key codes. If you have a list of `Key`s instead use {@link getKeyCodesFromKeys}.
+ *
+ * Useful for when the codes must be passed to a third-party library (for example, a dragging library that takes a list modifiers).
+ *
+ * This properly takes a look at the key and all it's variants.
+ *
+ * `skipIdIfHasVariants` is true by default and will skip adding the key's id if it has variants as it's assumed the id is not a valid name.
+ */
+export declare function getKeyCodesFromKeyIds(keyIds: string[], keys: Keys, opts: Parameters<typeof getKeyCodesFromKeys>[1]): string[];

package/dist/helpers/getKeyCodesFromKeyIds.js

@@ -0,0 +1,6 @@
+import { getKeyCodesFromKeys } from "./getKeyCodesFromKeys.js";
+import { getKeyFromIdOrVariant } from "./getKeyFromIdOrVariant.js";
+export function getKeyCodesFromKeyIds(keyIds, keys, opts) {
+  const keysList = keyIds.flatMap((id) => getKeyFromIdOrVariant(id, keys).unwrap());
+  return getKeyCodesFromKeys(keysList, opts);
+}

package/dist/helpers/getKeyCodesFromKeys.js

@@ -1,7 +1,7 @@
 export function getKeyCodesFromKeys(keys, { skipIdIfHasVariants = true } = {}) {
   const res = /* @__PURE__ */ new Set();
   for (const key of keys) {
-    if (key.variants) {
+    if (key.variants && key.variants.length > 0) {
       if (!skipIdIfHasVariants) {
         res.add(key.id);
       }

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "witchcraftSpellcraft",
   "configKey": "witchcraftSpellcraft",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/types.d.ts

@@ -1,7 +1,8 @@
+import type { OrToAnd } from "@alanscodelog/utils/types";
 export interface Register {
 }
 export type ExtendedShortcutManagerInfo = keyof Register extends `ShortcutManagerContext${infer T}` ? Register extends Record<`ShortcutManagerContext${T}`, infer U> ? U : {} : {};
-export type ContextInfo = ExtendedShortcutManagerInfo & {
+export type ContextInfo = OrToAnd<ExtendedShortcutManagerInfo> & {
     count: Record<string, number>;
     isActive: Record<string, boolean>;
 };

package/dist/types/condition.d.ts

@@ -24,6 +24,8 @@ export interface Condition {
  * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
  *
  * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ *
+ * This is why the manager now has the option `shortcutEqualityStrategy` which can be se to `ignoreCommandWithDifferentCondition`. You can implement a comparer that only checks when a command is being checked.
  */
-export type ConditionComparer = (conditionA?: Condition, conditionB?: Condition) => boolean;
+export type ConditionComparer = (conditionA: Condition | undefined, conditionB: Condition | undefined, type: "shortcut" | "command") => boolean;
 export type ConditionEvaluator<TContext extends Context<any>> = (condition: Condition, context: TContext) => boolean;

package/dist/types/manager.d.ts

@@ -114,9 +114,20 @@ export type Manager<THooks extends Partial<Hooks> = Partial<Hooks>, TKeys extend
         /**
          * Determines if two conditions are equal.
          *
-         * This is actually not a good idea to implement if you use boolean conditions. See {@link ConditionComparer} for why.
+         * This is actually not a good idea to implement for shortcuts if you use boolean conditions. See {@link ConditionComparer} for why.
+         *
+         * See also {@link Manager.options.shortcutEqualityStrategy}.
          */
         conditionEquals: ConditionComparer;
+        /**
+         * Determines how shortcuts are compared.
+         *
+         * - `ignoreCommand` (default) will ignore both shortcuts' commands. If everything else is equal, they are considered equal.
+         * - `ignoreCommandWithDifferentCondition` will ignore both commands' names and only compare their conditions. If everything else is equal, they are considered equal. Use it if you allow command conditions to equal eachother. See {@link ConditionComparer} for details.
+         * - `all` will compare everything.
+         *
+         */
+        shortcutEqualityStrategy: "ignoreCommand" | "ignoreCommandWithDifferentCondition" | "all";
         /** Determines how conditions are evaluated. */
         evaluateCondition: ConditionEvaluator<TContext>;
         /** Enable/disable triggering of shortcuts. The manager otherwise works as normal. */

package/dist/types/shortcuts.d.ts

@@ -126,12 +126,12 @@ export type CanHookShortcutProps = Exclude<OnHookShortcutProps, "forceUnequal">;
 export type SyntheticOnHookShortcutsProps = "entries@add" | "entries@remove";
 export type CanHookShortcutsProps = SyntheticOnHookShortcutsProps;
 export type OnHookShortcutsProps = SyntheticOnHookShortcutsProps;
-type BaseShortcutsManager = Pick<Manager, "keys" | "commands" | "shortcuts"> & PickManager<"options", "evaluateCondition" | "conditionEquals" | "stringifier"> & Record<any, any>;
+type BaseShortcutsManager = Pick<Manager, "keys" | "commands" | "shortcuts"> & PickManager<"options", "evaluateCondition" | "conditionEquals" | "stringifier" | "shortcutEqualityStrategy"> & Record<any, any>;
 export type ShortcutsSetEntries = {
     "entries@add": {
         val: Shortcut;
         hooks: GetShortcutHooks<`entries@add`>;
-        manager: BaseShortcutsManager & PickManager<"options", "sorter">;
+        manager: BaseShortcutsManager & PickManager<"options", "sorter" | "shortcutEqualityStrategy">;
         error: typeof SHORTCUT_ERROR.DUPLICATE_SHORTCUT | typeof SHORTCUT_ERROR.UNKNOWN_COMMAND | ChainError;
     };
     "entries@remove": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@witchcraft/spellcraft",
   "description": "A shortcut manager library for handling ALL the shortcut needs of an application.",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/core/index.js",
   "sideEffects": false,
@@ -39,7 +39,7 @@
     }
   },
   "peerDependencies": {
-    "@witchcraft/expressit": "^0.4.1",
+    "@witchcraft/expressit": "^0.4.2",
     "@witchcraft/ui": "^0.3.20"
   },
   "peerDependenciesMeta": {
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@alanscodelog/utils": "^6.0.2",
-    "@witchcraft/expressit": "^0.4.1",
+    "@witchcraft/expressit": "^0.4.2",
     "@witchcraft/ui": "^0.3.20",
     "reka-ui": "^2.8.0",
     "vue": "^3.5.27"

package/src/core/createManagerOptions.ts

@@ -16,6 +16,7 @@ export function createManagerOptions(
 	rawOpts: Parameters<typeof createManager>[0]["options"]
 ): Manager["options"] {
 	const options: Manager["options"] = {
+		shortcutEqualityStrategy: "ignoreCommand",
 		sorter: defaultSorter,
 		stringifier: defaultStringifier,
 		conditionEquals: defaultConditionEquals,

package/src/core/createShortcuts.ts

@@ -17,7 +17,7 @@ export function createShortcuts<
 >(
 	shortcutsList: TRawShortcuts,
 	manager: Pick<Manager, "keys" | "commands">
-		& PickManager<"options", | "evaluateCondition" | "conditionEquals" | "stringifier" | "sorter">
+		& PickManager<"options", | "evaluateCondition" | "conditionEquals" | "stringifier" | "sorter" | "shortcutEqualityStrategy">
 		& { hooks?: THooks },
 	opts?: Partial<Pick<Shortcuts, "ignoreModifierConflicts" | "ignoreChainConflicts">>,
 	{

package/src/core/setShortcutsProp.ts

@@ -43,7 +43,7 @@ export function setShortcutsProp<
 
 				const shortcut = val as any as Shortcut
 				const existing = (shortcuts.entries).find(_ =>
-					equalsShortcut(shortcut, _, manager, { ignoreCommand: true })
+					equalsShortcut(shortcut, _, manager)
 					|| doesShortcutConflict(_, shortcut, manager)
 				)
 
@@ -67,7 +67,7 @@ export function setShortcutsProp<
 				const shortcut = val as any as Shortcut
 				// note we don't ignore the command here, we want to find an exact match
 				const existing = (shortcuts.entries).find(_ =>
-					_ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false })
+					_ === shortcut || equalsShortcut(shortcut, _, manager, { shortcutEqualityStrategy: "all" })
 				)
 				if (existing === undefined) {
 					return Err(new KnownError(
@@ -105,7 +105,7 @@ export function setShortcutsProp<
 		}
 		case "entries@remove": {
 			const shortcut = val
-			const i = shortcuts.entries.findIndex(_ => _ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false }))
+			const i = shortcuts.entries.findIndex(_ => _ === shortcut || equalsShortcut(shortcut, _, manager, { shortcutEqualityStrategy: "all" }))
 			if (i < 0) {
 				throw new Error("If used correctly, shortcut should exist at this point, but it does not.")
 			}

package/src/defaults/defaultConditionEquals.ts

@@ -1,25 +1,12 @@
 import type { Condition } from "../types/index.js"
 
 /**
- * Returns whether the condition passed is equal to this one.
- *
- * The default method does a simplistic object check, and otherwise a  check of the `text` property for equality. If both conditions are undefined, note this will return true.
- *
- * If you override the default conditionEquals option you will likely want it to just always return false.
- *
- * Why? Because unless you're using simple single variable conditions that you can presort to make them uniquely identifiable (i.e. not boolean expressions, e.g. `!a b !c`), this will return A LOT of false negatives.
- *
- * Why the false negatives? Because two conditions might be functionally equal but have differing representations (e.g: `a && b`, `b && a`). You might think, lets normalize them all, but normalizing boolean expressions (converting them to CNF) can be dangerous with very long expressions because it can take exponential time.
- *
- * Now the main reason for checking the equality of two conditions is to check if two shortcuts might conflict. If we're using boolean expressions it just can't be done safely.
- *
- * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
- *
- * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ * IMPORTANT: Please read {@link ConditionComparer} before using.
  */
 export function defaultConditionEquals<TCondition extends Condition>(
-	conditionA?: TCondition,
-	conditionB?: Condition
+	conditionA: TCondition | undefined,
+	conditionB: Condition | undefined,
+	_type: "shortcut" | "command"
 ): conditionB is TCondition {
 	// both are the same object or both undefined
 	if (conditionA === conditionB) return true

package/src/helpers/doesShortcutConflict.ts

@@ -23,7 +23,7 @@ export function doesShortcutConflict<TShortcut extends Shortcut>(
 	shortcutA: TShortcut,
 	shortcutB: Shortcut,
 	manager: Pick<Manager, "keys" | "commands" | "shortcuts"> & { context?: Manager["context"] }
-		& PickManager<"options", "evaluateCondition" | "conditionEquals">
+		& PickManager<"options", "evaluateCondition" | "conditionEquals" | "shortcutEqualityStrategy">
 ): boolean {
 	const context = manager.context
 	if (!context && manager.shortcuts.useContextInConflictCheck) {
@@ -47,7 +47,7 @@ export function doesShortcutConflict<TShortcut extends Shortcut>(
 			if (!shortcutCondition) return false
 		}
 	} else {
-		if	(!conditionEquals(shortcutA.condition, shortcutB.condition)) return false
+		if	(!conditionEquals(shortcutA.condition, shortcutB.condition, "shortcut")) return false
 	}
 	const { keys } = manager
 	// an empty chain is always in conflict ?

package/src/helpers/equalsCommand.ts

@@ -13,6 +13,6 @@ export function equalsCommand<TCommand extends Command>(
 	if (commandA === commandB) return true
 	return commandA.name === commandB.name
 		&& commandA.execute === commandB.execute
-		&& manager.options.conditionEquals(commandA.condition, commandB.condition)
+		&& manager.options.conditionEquals(commandA.condition, commandB.condition, "command")
 		&& commandA.description === commandB.description
 }

package/src/helpers/equalsShortcut.ts

@@ -6,20 +6,32 @@ import { equalsKeys } from "../utils/equalsKeys.js"
 /**
  * Returns whether the shortcut passed is equal to shortcutA one.
  *
- * To return true, their keys and command must be equal (unless ignoreCommand is passed), their condition must be equal according to shortcutA shortcut's condition.
+ * To return true, their keys, conditions, and commands (depends on the configured `manager.options.shortcutEqualityStrategy`) must be equal.
+ *
+ * See {@link Manager.options.shortcutEqualityStrategy} for details.
+ *
+ * You can temporarily override the strategy witht the third parameter.
  */
 export function equalsShortcut<TShortcut extends Shortcut>(
 	shortcutA: TShortcut,
 	shortcutB: Shortcut,
-	manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", | "evaluateCondition" | "conditionEquals">,
-	{ ignoreCommand = false }: { ignoreCommand?: boolean } = {}
+	manager: Pick<Manager, "keys" | "commands"> & PickManager<"options", | "evaluateCondition" | "conditionEquals" | "shortcutEqualityStrategy">,
+	overrides?: PickManager<"options", "shortcutEqualityStrategy">["options"]
 ): shortcutB is TShortcut {
 	if (shortcutA.forceUnequal || shortcutB.forceUnequal) return false
 	if (shortcutA === shortcutB) return true
+	const commandA = shortcutA.command ? manager.commands.entries[shortcutA.command] : undefined
+	const commandB = shortcutB.command ? manager.commands.entries[shortcutB.command] : undefined
+	const shortcutEqualityStrategy = overrides?.shortcutEqualityStrategy ?? manager.options.shortcutEqualityStrategy
 	return (
 		equalsKeys(shortcutA.chain, shortcutB.chain, manager.keys, undefined, { allowVariants: true })
-		&& manager.options.conditionEquals(shortcutA.condition, shortcutB.condition)
-		&& (ignoreCommand
+		&& manager.options.conditionEquals(shortcutA.condition, shortcutB.condition, "shortcut")
+		&& (shortcutEqualityStrategy === "ignoreCommand"
+			|| (
+				shortcutEqualityStrategy === "ignoreCommandWithDifferentCondition"
+				&& commandA?.condition && commandB?.condition
+				&& manager.options.conditionEquals(commandA.condition, commandB.condition, "command")
+			)
 			|| (
 				shortcutA.command === shortcutB.command
 				&& shortcutA.command === undefined

package/src/helpers/getKeyCodesFromKeyIds.ts

@@ -0,0 +1,20 @@
+import { getKeyCodesFromKeys } from "./getKeyCodesFromKeys.js"
+import { getKeyFromIdOrVariant } from "./getKeyFromIdOrVariant.js"
+
+import type { Keys } from "../types/keys.js"
+
+/**
+ * Given an list of key ids, returns an array of deduped key codes. If you have a list of `Key`s instead use {@link getKeyCodesFromKeys}.
+ *
+ * Useful for when the codes must be passed to a third-party library (for example, a dragging library that takes a list modifiers).
+ *
+ * This properly takes a look at the key and all it's variants.
+ *
+ * `skipIdIfHasVariants` is true by default and will skip adding the key's id if it has variants as it's assumed the id is not a valid name.
+ */
+
+
+export function getKeyCodesFromKeyIds(keyIds: string[], keys: Keys, opts: Parameters<typeof getKeyCodesFromKeys>[1]): string[] {
+	const keysList = keyIds.flatMap(id => getKeyFromIdOrVariant(id, keys).unwrap())
+	return getKeyCodesFromKeys(keysList, opts)
+}

package/src/helpers/getKeyCodesFromKeys.ts

@@ -13,7 +13,7 @@ import type { Key } from "../types/keys.js"
 export function getKeyCodesFromKeys(keys: Key[], { skipIdIfHasVariants = true}: { skipIdIfHasVariants?: boolean } = {}): string[] {
 	const res = new Set<string>()
 	for (const key of keys) {
-		if (key.variants) {
+		if (key.variants && key.variants.length > 0) {
 			if (!skipIdIfHasVariants) {
 				res.add(key.id)
 			}

package/src/runtime/types.ts

@@ -1,3 +1,4 @@
+import type { OrToAnd } from "@alanscodelog/utils/types"
 // allows users to register multiple contexts
 // @eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface Register {}
@@ -16,7 +17,7 @@ export type ExtendedShortcutManagerInfo = keyof Register extends `ShortcutManage
 	: {}
 
 
-export type ContextInfo = ExtendedShortcutManagerInfo & {
+export type ContextInfo = OrToAnd<ExtendedShortcutManagerInfo> & {
 	count: Record<string, number>
 	isActive: Record<string, boolean>
 }

package/src/types/condition.ts

@@ -28,8 +28,10 @@ export interface Condition {
  * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
  *
  * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ *
+ * This is why the manager now has the option `shortcutEqualityStrategy` which can be se to `ignoreCommandWithDifferentCondition`. You can implement a comparer that only checks when a command is being checked.
  */
-export type ConditionComparer = (conditionA?: Condition, conditionB?: Condition) => boolean
+export type ConditionComparer = (conditionA: Condition | undefined, conditionB: Condition | undefined, type: "shortcut" | "command") => boolean
 
 export type ConditionEvaluator<TContext extends Context<any>> = (condition: Condition, context: TContext) => boolean
 

package/src/types/manager.ts

@@ -212,9 +212,21 @@ export type Manager<
 		/**
 		 * Determines if two conditions are equal.
 		 *
-		 * This is actually not a good idea to implement if you use boolean conditions. See {@link ConditionComparer} for why.
+		 * This is actually not a good idea to implement for shortcuts if you use boolean conditions. See {@link ConditionComparer} for why.
+		 *
+		 * See also {@link Manager.options.shortcutEqualityStrategy}.
 		 */
 		conditionEquals: ConditionComparer
+		/**
+		 * Determines how shortcuts are compared.
+		 *
+		 * - `ignoreCommand` (default) will ignore both shortcuts' commands. If everything else is equal, they are considered equal.
+		 * - `ignoreCommandWithDifferentCondition` will ignore both commands' names and only compare their conditions. If everything else is equal, they are considered equal. Use it if you allow command conditions to equal eachother. See {@link ConditionComparer} for details.
+		 * - `all` will compare everything.
+		 *
+		 */
+		shortcutEqualityStrategy: "ignoreCommand" | "ignoreCommandWithDifferentCondition" | "all"
+
 		/** Determines how conditions are evaluated. */
 		evaluateCondition: ConditionEvaluator<TContext>
 		/** Enable/disable triggering of shortcuts. The manager otherwise works as normal. */

package/src/types/shortcuts.ts

@@ -178,7 +178,7 @@ export type OnHookShortcutsProps = SyntheticOnHookShortcutsProps
 
 type BaseShortcutsManager
 	= & Pick<Manager, "keys" | "commands" | "shortcuts">
-		& PickManager<"options", | "evaluateCondition" | "conditionEquals" | "stringifier">
+		& PickManager<"options", | "evaluateCondition" | "conditionEquals" | "stringifier" | "shortcutEqualityStrategy">
 		& Record<any, any>
 
 export type ShortcutsSetEntries = {
@@ -187,7 +187,7 @@ export type ShortcutsSetEntries = {
 		val: Shortcut
 		hooks: GetShortcutHooks<`entries@add`>
 		manager: BaseShortcutsManager
-			& PickManager<"options", "sorter">
+			& PickManager<"options", "sorter" | "shortcutEqualityStrategy">
 
 		error:
 			| typeof SHORTCUT_ERROR.DUPLICATE_SHORTCUT