@witchcraft/spellcraft 0.0.1

package/src/runtime/composables/useShortcutManagerVirtualPress.ts

@@ -0,0 +1,30 @@
+import { type Ref, ref } from "vue"
+
+import type { ManagerListener } from "../../types/index.js"
+
+export function useShortcutManagerVirtualPress(): {
+	virtuallyPressedKeys: Ref<Record<string, boolean>>
+	updateVirtuallyPressed: ManagerListener
+} {
+	const virtuallyPressedKeys = ref<Record<string, boolean>>({})
+	function updateVirtuallyPressed(arg: Parameters<ManagerListener>[0]): void {
+		const { event, keys, isKeydown } = arg
+		if (!event) {
+			for (const key of keys) {
+				if (isKeydown) {
+					virtuallyPressedKeys.value[key] = true
+				} else {
+					delete virtuallyPressedKeys.value[key]
+				}
+			}
+		} else {
+			for (const key of keys) {
+				delete virtuallyPressedKeys.value[key]
+			}
+		}
+	}
+	return {
+		virtuallyPressedKeys,
+		updateVirtuallyPressed
+	}
+}

package/src/runtime/types.ts

@@ -0,0 +1,10 @@
+export interface Register { }
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+type ExtendedContextInfo = Register extends { ExtendedContextInfo: infer T } ? T : unknown
+
+export type ContextInfo = ExtendedContextInfo & {
+	count: Record<string, number>
+	isActive: Record<string, boolean>
+}
+export {}

package/src/runtime/utils/shortcutToId.ts

@@ -0,0 +1,14 @@
+import type { PickManager } from "../../types/general.js"
+import type { Manager } from "../../types/manager.js"
+import type { Shortcut } from "../../types/shortcuts.js"
+
+/** Turns a shortcut into an id to use in a v-for loop. */
+export const shortcutToId = (
+	shortcut: Shortcut,
+	manager: PickManager<"options", "stringifier"> & Pick<Manager, "keys">
+): string => [
+	shortcut.enabled,
+	manager.options.stringifier.stringify(shortcut.chain, manager),
+	shortcut.command ?? "",
+	shortcut.condition.text
+].join("--")

package/src/types/commands.ts

@@ -0,0 +1,148 @@
+import type { Condition } from "./condition.js"
+import type { Context } from "./context.js"
+import type { SHORTCUT_ERROR } from "./enums.js"
+import type { PickManager } from "./general.js"
+import type { AnyInputEvent, Manager, MinimalInputEvent } from "./manager.js"
+import type { Shortcut } from "./shortcuts.js"
+
+
+export type RawCommand<TName extends string = string> = Pick<Command<TName>, "name"> & Partial<Command<TName>>
+
+export type CommandExecute<TName extends string = string> = <
+
+	T extends AnyInputEvent | MinimalInputEvent = AnyInputEvent | MinimalInputEvent
+>(args: {
+	isKeydown: boolean
+	command: Command<TName>
+	shortcut?: Shortcut<TName> | undefined
+	/**
+	 * The event that triggered the command. It might be undefined if a virtual event triggered the key. It's typed as {@link AnyInputEvent} because you might also receive Emulated events from the {@link Emulator} if you use it. If you don't you can safely ignore the {@link EmulatedEvent} type or type the execute function as `CommandExecute<AnyInputEvent>`
+	 */
+	event?: T
+	/**
+	 * The manager might be undefined. This is to allow calling the command manually without it.
+	 */
+	manager?: Manager
+	context: Context
+}) => void
+
+export interface Command<
+	TName extends
+	string = string,
+	TExec extends CommandExecute<string> = CommandExecute<string>,
+	TCondition extends
+	Condition = Condition
+> {
+	readonly type: "command"
+	/**
+	 * Unique string to identify the command by.
+	 *
+	 * Note that when changing a command's name, it is not an error for the old command to not exist in the manager. This is to allow for easier checking if a command can be added. If you need it to be an error, you can add a canSetCommand hook.
+	 *
+	 * @RequiresSet @OnHookable @CanHookable
+	 */
+	readonly name: TName
+	/**
+	 * The function to execute when a shortcut triggers it's command. It is executed both on keydown and keyup (of the first released key) so be sure to check the isKeydown parameter so you don't trigger commands twice.
+	 *
+	 * The command itself is passed to it, and if it is managed by a manager it is also passed the shortcut, the manager itself, and the event of the last key that triggered it. Note the event might not exist when the manager needs to emulate a key release. See {@link Manager.autoReleaseDelay}.
+	 *
+	 * You should do `e.preventDefault` if you need it or haven't done so from {@link Manager.eventFilter}.
+	 *
+	 * You should also do {@link safeSetManagerChain} on keyup for most regular shortcuts. See it for details.
+	 *
+	 * See {@link Manager}.
+	 *
+	 * @RequiresSet @OnHookable @CanHookable
+	 */
+	readonly execute?: TExec
+	/**
+	 * Commands may have an additional condition that must be met, apart from the shortcut's that triggered it.
+	 *
+	 * If the command is created without a condition, it is assigned a blank condition. If you are using a custom condition class, you should probably always pass a blank condition.
+	 *
+	 * @RequiresSet @OnHookable @CanHookable
+	 */
+	readonly condition: TCondition
+	/**
+	 * A description of what the command does.
+	 *
+	 * @RequiresSet @OnHookable @CanHookable
+	 */
+	readonly description: string
+}
+
+export type Commands<
+	TEntries extends Record<string, Command> = Record<string, Command>
+> = {
+	type: "commands"
+	/**
+	 * The command entries.
+	 *
+	 * To add/remove entries you should {@link addCommand}/{@link removeCommand} or {@link setCommandsProp} with the synthetic `entries@add/remove` properties.
+	 *
+	 * The synthetic properties can be hooked into with {@link Manager.hooks}.
+	 *
+	 * @RequiresSet @OnHookable @Managed
+	 */
+
+	entries: TEntries
+}
+export type RawCommands = Pick<Commands, "entries"> & Partial<Commands>
+
+
+type GetCommandHooks<T extends keyof CommandSetEntries | keyof CommandsSetEntries>
+	= T extends CanHookCommandProps
+		? Partial<Pick<NonNullable<Manager["hooks"]>, "canSetCommandProp" | "onSetCommandProp">>
+		: T extends OnHookCommandProps
+			? Partial<Pick<NonNullable<Manager["hooks"]>, "onSetCommandProp">>
+			: T extends CanHookCommandsProps
+				? Partial<Pick<NonNullable<Manager["hooks"]>, "canSetCommandsProp" | "onSetCommandsProp">>
+				: Partial<Pick<NonNullable<Manager["hooks"]>, "onSetCommandsProp">>
+
+type Unmanaged<T extends keyof Command & keyof CommandSetEntries> = {
+	val: Command[T]
+	manager: never
+	hooks: GetCommandHooks<T>
+	error: never
+}
+
+export type CommandSetEntries = {
+	condition: Unmanaged<"condition">
+	execute: Unmanaged<"execute">
+	description: Unmanaged<"description">
+	name: {
+		val: string
+		manager: Pick<Manager, "commands" | "shortcuts" | "keys"> & PickManager<"options", "stringifier">
+		hooks: GetCommandHooks<"name">
+		// see name above, missing should NOT be an error
+		error: typeof SHORTCUT_ERROR.COMMAND_IN_USE | typeof SHORTCUT_ERROR.DUPLICATE_COMMAND | typeof SHORTCUT_ERROR.MULTIPLE_ERRORS
+	}
+}
+export type OnHookCommandProps = "condition" | "execute" | "description"
+export type CanHookCommandProps = OnHookCommandProps
+
+type BaseCommandsManager = PickManager<"options", "stringifier"> & Record<any, any>
+	& Pick<Manager, "commands">
+
+export type CommandsSetEntries = {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	"entries@add": {
+		val: Command
+		hooks: GetCommandHooks<`entries@add`>
+		manager: BaseCommandsManager
+		error: typeof SHORTCUT_ERROR.DUPLICATE_COMMAND
+	}
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	"entries@remove": {
+		val: Command
+		hooks: GetCommandHooks<`entries@remove`>
+		manager: BaseCommandsManager & Pick<Manager, "shortcuts" | "keys">
+		error: typeof SHORTCUT_ERROR.COMMAND_IN_USE | typeof SHORTCUT_ERROR.MISSING
+	}
+}
+
+export type SyntheticOnHookCommandsProps = "entries@add" | "entries@remove"
+export type CanHookCommandsProps = SyntheticOnHookCommandsProps
+export type OnHookCommandsProps = SyntheticOnHookCommandsProps
+

package/src/types/condition.ts

@@ -0,0 +1,35 @@
+import type { Context } from "./context.js"
+
+
+export type RawCondition = string
+
+/**
+	* This just describes a condition. No logic to parse/evaluate them is provided and a third party library should be used. The {@link ConditionEvaluator} can then be used to specify how to evaluate them.
+	*/
+export interface Condition {
+	type: "condition"
+	/**
+	 * The main text representation of the condition. Note that this is NOT a unique identifier for conditions and cannot be used to compare them if you are using boolean expressions for your conditions. See {@link Condition.constructor} for an explanation.
+	 */
+	text: string
+}
+
+/**
+ * Returns whether the condition passed is equal to this one.
+ *
+ * The default method does a simplistic check of the `text` property for equality. If you override the method 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, but something like `!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).
+ */
+export type ConditionComparer = (conditionA?: Condition, conditionB?: Condition) => boolean
+
+export type ConditionEvaluator<TContext extends Context<any>> = (condition: Condition, context: TContext) => boolean
+

package/src/types/context.ts

@@ -0,0 +1,19 @@
+export interface RecursiveRecord {
+	[key: string]: any | RecursiveRecord
+}
+/**
+ * # Context
+ *
+ * Like {@link Condition}, provides a way to describe contexts. How contexts look and work is up to you.
+ *
+ * Contexts describe the relevant application state. They are what {@link Condition}s are evaluated against.
+ *
+ * @template TValue **@internal** Captures the type of the context value.
+ */
+
+export type Context<TValue extends object = any> = {
+	type: "context"
+	/** Where the context object is stored. */
+	value: TValue
+}
+export type RawContext = Pick<Context, "value"> & Partial<Context>

package/src/types/enums.ts

@@ -0,0 +1,236 @@
+import type { EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray"
+
+import type { Command, Commands } from "./commands.js"
+import type { Key, Keys } from "./keys.js"
+import type { AnyInputEvent } from "./manager.js"
+import type { Shortcut, Shortcuts } from "./shortcuts.js"
+
+import type { KnownError } from "../helpers/index.js"
+
+/**
+ * All possible errors.
+ */
+export const SHORTCUT_ERROR = enumFromArray([
+	// === shortcut init related problems
+	"CHORD_W_ONLY_MODIFIERS",
+	"CHORD_W_MULTIPLE_TRIGGER_KEYS",
+	"CHORD_W_MULTIPLE_WHEEL_KEYS",
+	"CHORD_W_DUPLICATE_KEY",
+	"IMPOSSIBLE_TOGGLE_SEQUENCE",
+	"MISSING", // removing
+	"INVALID_VARIANT",
+	"INVALID_VARIANT_PAIR",
+
+	// === duplicate "bases"
+	"DUPLICATE_KEY",
+	"DUPLICATE_COMMAND",
+	"DUPLICATE_SHORTCUT",
+
+	// === other
+	"INVALID_SWAP_CHORDS",
+	"CANNOT_SET_WHILE_DISABLED",
+
+	// === manager
+	"MULTIPLE_MATCHING_SHORTCUTS",
+	"INCORRECT_TOGGLE_STATE",
+	"NO_MATCHING_SHORTCUT",
+	"UNKNOWN_KEY",
+	"UNKNOWN_KEY_ID",
+	"UNKNOWN_COMMAND",
+	"KEY_IN_USE",
+	"COMMAND_IN_USE",
+	"UNKNOWN_KEY_EVENT",
+	"MULTIPLE_ERRORS",
+	"INVALID_MANAGER"
+])
+export type ShortcutError = EnumLike<typeof SHORTCUT_ERROR>
+
+export type ChainError
+	= | typeof SHORTCUT_ERROR.UNKNOWN_KEY
+		| typeof SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY
+		| typeof SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS
+		| typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS
+		| typeof SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS
+		| typeof SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE
+
+/** Errors that will throw since they should be caught at production. */
+
+export const TYPE_ERROR = enumFromArray([
+	"ILLEGAL_OPERATION",
+	"HOOK_OR_LISTENER_DOES_NOT_EXIST",
+	"FILTER_DOES_NOT_EXIST"
+])
+export type TypeError = EnumLike<typeof TYPE_ERROR>
+
+/**
+ * Defines the properties attached to each error.
+ *
+ * Makes it easy to define the properties attached to each error by just allowing passing the error (regardless of error type) as T in [[KnownError]] and [[InternalError]].
+ */
+
+export type ErrorInfo<T extends ShortcutError | TypeError>
+	= T extends ShortcutError
+		? ERROR_Info[T]
+		: never
+
+/** Type multiple {@link KnownError} errors to work like a discriminated union. */
+export type MultipleErrors<T extends ShortcutError | TypeError> = {
+	[k in T]: KnownError<k>
+}[T]
+
+// note all these error types could be kept in the same type, but then we'd have to make all the keys unique and we can't because internal errors should use the same key
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+type ERROR_Info = {
+	// === shortcut init related problems
+	[SHORTCUT_ERROR.CHORD_W_ONLY_MODIFIERS]: {
+		chord: string[]
+		i: number
+		keys: string[]
+	}
+	[SHORTCUT_ERROR.CHORD_W_MULTIPLE_TRIGGER_KEYS]: {
+		chord: string[]
+		i: number
+		keys: string[]
+	}
+	[SHORTCUT_ERROR.CHORD_W_MULTIPLE_WHEEL_KEYS]: {
+		chord: string[]
+		i: number
+		keys: string[]
+	}
+	[SHORTCUT_ERROR.CHORD_W_DUPLICATE_KEY]: {
+		chord: string[]
+		i: number
+		keys: string[]
+	}
+	[SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE]: {
+		chain: string[][]
+		i: number
+		key: Key
+	}
+	[SHORTCUT_ERROR.MISSING]: {
+		entry: Key | Shortcut | Command | string
+		self: Keys | Shortcuts | Commands
+	}
+	[SHORTCUT_ERROR.INVALID_VARIANT]: {
+		variants: string[]
+		id: string
+	}
+	[SHORTCUT_ERROR.INVALID_VARIANT_PAIR]: {
+		variants: Key[]
+		key: Key
+		otherKey: Key
+	}
+
+	[SHORTCUT_ERROR.DUPLICATE_KEY]: {
+		existing: Key
+		self: Keys
+	}
+	[SHORTCUT_ERROR.DUPLICATE_SHORTCUT]: {
+		existing: Shortcut
+		self: Shortcuts
+		/** If the error is caused by a change, key and value will contain the new key and value. */
+		key?: string
+		value?: any
+	}
+	[SHORTCUT_ERROR.DUPLICATE_COMMAND]: {
+		existing: Command
+		self: Commands
+	}
+
+
+	// === other
+	[SHORTCUT_ERROR.INVALID_SWAP_CHORDS]:
+		{
+			chord: string[][]
+		}
+		| {
+			chordsA: string[][]
+			chordsB: string[][]
+		}
+
+	[SHORTCUT_ERROR.CANNOT_SET_WHILE_DISABLED]:
+	{
+		key: Key
+	}
+
+	// === manager
+	[SHORTCUT_ERROR.MULTIPLE_MATCHING_SHORTCUTS]: {
+		shortcuts: Shortcut[]
+	}
+	[SHORTCUT_ERROR.INCORRECT_TOGGLE_STATE]: {
+		key: Key
+	}
+	[SHORTCUT_ERROR.NO_MATCHING_SHORTCUT]: {
+		chain: string[][]
+	}
+	[SHORTCUT_ERROR.UNKNOWN_KEY]: {
+		shortcut?: Pick<Shortcut, "chain">
+		keys: string[] | Keys
+	}
+	[SHORTCUT_ERROR.UNKNOWN_COMMAND]: {
+		shortcut?: Pick<Shortcut, "chain" | "command">
+		command: string
+		commands: string[] | Commands
+	}
+	[SHORTCUT_ERROR.MULTIPLE_ERRORS]: {
+		errors: Error[]
+	}
+	[SHORTCUT_ERROR.KEY_IN_USE]: {
+		inUseShortcuts: Shortcut[]
+	}
+	[SHORTCUT_ERROR.COMMAND_IN_USE]: {
+		inUseShortcuts: Shortcut[]
+	}
+	[SHORTCUT_ERROR.UNKNOWN_KEY_EVENT]: {
+		e: AnyInputEvent
+		button?: string
+		code?: string
+		key?: string
+		deltaY?: number | string
+	}
+	[SHORTCUT_ERROR.UNKNOWN_KEY_ID]: {
+		id: string
+	}
+	[SHORTCUT_ERROR.INVALID_MANAGER]: {
+		keys: string[]
+	}
+}
+
+
+export const MOUSE = enumFromArray([
+	"R",
+	"M",
+	"L",
+	"BACK",
+	"FORWARD"
+])
+export type Mouse = EnumLike<typeof MOUSE>
+
+export const WHEEL = enumFromArray([
+	"down",
+	"up"
+])
+export type Wheel = EnumLike<typeof WHEEL>
+
+
+// These do not need to be initialized, we want the order they're declared in.
+export const KEY_SORT_POS = {
+	mod: 0,
+	modmouse: 1,
+	// modmousewheel = error
+	modwheel: 2, // weird...
+	modtoggle: 3, // weird...
+	modtogglemouse: 4, // weird...
+	modtogglewheel: 5, // weird...
+	// modtogglemousewheel = error
+	normal: 6,
+	mouse: 7,
+	wheel: 8,
+	toggle: 9,
+	togglemouse: 10,
+	togglewheel: 11 // weird...
+	// modtogglemousewheel = error
+}
+

package/src/types/general.ts

@@ -0,0 +1,117 @@
+import type { Command } from "./commands.js"
+import type { Condition } from "./condition.js"
+import type { Key } from "./keys.js"
+import type { Manager } from "./manager.js"
+import type { Shortcut } from "./shortcuts.js"
+
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export type NavigatorWKeyboard = {
+	keyboard?: {
+		/**
+			* {@link https://developer.mozilla.org/en-US/docs/Web/API/Keyboard/getLayoutMap getLayoutMap}
+			*/
+		getLayoutMap(): Promise<KeyboardLayoutMap>
+	}
+}
+export type KeyCode = string
+export type KeyLabel = string
+export type KeyboardLayoutMap = Map<KeyCode, KeyLabel>
+export type AttachTarget = {
+	addEventListener: HTMLElement["addEventListener"]
+	removeEventListener: HTMLElement["removeEventListener"]
+}
+
+export type DefaultStringifierOptions = {
+	/**
+	 * The key parameter will be undefined for unknown keys.
+	 * Also careful with toggle keys, you will need to check which toggle it is by checking against the toggle ids.
+	 */
+	key?: (id: string, key?: Key) => string
+	chord?: (key: readonly string[]) => string
+	chain?: (key: readonly string[]) => string
+	shortcut?: (shortcut: Shortcut) => string
+	command?: (command?: Command) => string
+	condition?: (condition?: Condition) => string
+	propertyValue?: (propertyValue?: any) => string
+	list?: (items: string[], type: "keys" | "commands" | "shortcuts") => string
+}
+
+export type StringifyCommandList = { type: "command", list: string[] }
+export type StringifyKeyList = { type: "key", list: string[] }
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export type IStringifier = {
+	stringify(
+		entry: Shortcut,
+		manager: Pick<Manager, "keys" | "commands">
+	): string
+	/**
+	 * Stringifies single keys in string or {@link Key} from, as well as chords, chains, full shortcuts, and commands.
+	 *
+	 * In the case of string key ids and Shortcuts, some additional information is required to be able to convert the keys and commands back into the full commands and consistently stringify them.
+	 *
+	 */
+	stringify(
+		entry: string | string[] | string[][],
+		manager: Pick<Manager, "keys">
+	): string
+
+
+	stringify(
+		entry: Key | Key[] | Command | Condition,
+	): string
+
+	stringify(
+		entry: string | string[] | string[][] | Key | Key[] | Shortcut | Command | Condition,
+		manager: Pick<Manager, "keys" | "commands"> | Pick<Manager, "keys"> | never
+
+	): string
+	/** Stringifies the property values of items when there is an error (e.g. "You cannot change prop x from a to b because of y." a and b here being the property values). */
+	stringifyPropertyValue(entry: any): string
+	/**
+	 * Stringifies lists of keys, shortcuts, or commands.
+	 *
+	 * The type must be specified because we can't magically tell what type something is for string lists and/or empty lists.
+	 */
+	stringifyList(type: "keys", entries: Key[]): string
+	stringifyList(type: "commands", entries: Command[]): string
+	stringifyList(type: "keys", entries: string[], manager: Pick<Manager, "keys">): string
+	stringifyList(type: "commands", entries: string[], manager: Pick<Manager, "commands">): string
+	stringifyList(type: "shortcuts", entries: Shortcut[], manager: Pick<Manager, "keys" | "commands">): string
+	/**
+		* Stringifies commands by name (`stringify` interprets single strings as key ids.).
+		*/
+	stringifyCommand(name: string | undefined, manager: Pick<Manager, "commands">): string
+}
+
+
+export type PickManager<
+	TType extends "options" | "state" | "hooks",
+	TKeys extends keyof TManager[TType],
+	TManager extends Manager = Manager
+>
+	= Record<TType, Pick<TManager[TType], TKeys>>
+
+export type PickManagerHooks<T extends Manager["hooks"]> = {
+	hooks?: T
+}
+
+export type ShortcutInfo = {
+	shortcut: Shortcut
+	isPressableChain: boolean
+	isPressable: boolean
+	isPressed: boolean
+	/** If a shortcut contains unpressed modifiers, it will not be considered pressable or a pressable chain, but you will likely want to show a hint on the modifier anyways. */
+	hasUnpressedModifiers: boolean
+}
+
+export type KeyInfo = {
+	/** All shortcuts that contain this key and are either pressable, pressable chains, or pressed. */
+	pressableEntries: ShortcutInfo[]
+	/** All shortcuts that contain this key and are not pressable but have unpressed modifiers (see {@link ShortcutInfo.hasUnpressedModifiers}). */
+	modifierEntries: ShortcutInfo[]
+	/** Depending on the shortcut's list passed, or how conditions and contexts are implemented, it's possible for their to be conflicting shortcuts in certain contexts. */
+	containsConflicting: boolean
+	/** Indicates there are shortcuts in the modifierEntries, i.e. there are shortcuts that have unpressedModifiers (see {@link ShortcutInfo.hasUnpressedModifiers}). You will usually want to have some visual hint the modifier key can be pressed to show more shortcuts. */
+	isModifierHint: boolean
+}

package/src/types/index.ts

@@ -0,0 +1,10 @@
+/* Autogenerated Index [types] */
+
+export * from "./manager.js"
+export * from "./enums.js"
+export * from "./general.js"
+export * from "./commands.js"
+export * from "./condition.js"
+export * from "./keys.js"
+export * from "./shortcuts.js"
+export * from "./context.js"