@keybindy/react 1.1.0 → 1.1.1

package/dist/index.mjs

@@ -0,0 +1,232 @@
+'use client';
+
+// src/Keybindy.tsx
+import React2 from "react";
+
+// src/useKeybindy.tsx
+import React from "react";
+import ShortcutManager from "@keybindy/core";
+var sharedInstance = null;
+var useKeybindy = ({
+  logs = false,
+  onShortcutFired
+} = {}) => {
+  const managerRef = React.useRef(null);
+  const registeredIds = React.useRef(/* @__PURE__ */ new Set());
+  if (!sharedInstance) {
+    sharedInstance = new ShortcutManager({ onShortcutFired, silent: !logs });
+  }
+  if (!managerRef.current) {
+    managerRef.current = sharedInstance;
+  }
+  const log = (...args) => {
+    if (logs) console.log("[Keybindy]", ...args);
+  };
+  const warn = (...args) => {
+    if (logs) console.warn("[Keybindy]", ...args);
+  };
+  const register = React.useCallback(
+    (keys, handler, options) => {
+      if (keys.length === 0) {
+        warn("No keys provided to register");
+        return;
+      }
+      const id = options?.data?.id;
+      if (id) registeredIds.current.add(id);
+      log("Registered:", id ?? keys);
+      managerRef.current?.register(keys, handler, options);
+    },
+    []
+  );
+  const unregister = React.useCallback((keys, scope) => {
+    if (keys.length === 0) {
+      warn("No keys provided to unregister");
+      return;
+    }
+    managerRef.current?.unregister(keys, scope);
+    log("Unregistered:", keys);
+  }, []);
+  const enable = React.useCallback((keys, scope) => {
+    if (keys.length === 0) {
+      warn("No keys provided to enable");
+      return;
+    }
+    managerRef.current?.enable(keys, scope);
+    log("Enabled:", keys);
+  }, []);
+  const disable = React.useCallback((keys, scope) => {
+    if (keys.length === 0) {
+      warn("No keys provided to disable");
+      return;
+    }
+    managerRef.current?.disable(keys, scope);
+    log("Disabled:", keys);
+  }, []);
+  const toggle = React.useCallback((keys, scope) => {
+    if (keys.length === 0) {
+      warn("No keys provided to toggle");
+      return;
+    }
+    managerRef.current?.toggle(keys, scope);
+    log("Toggled:", keys);
+  }, []);
+  const getCheatSheet = React.useCallback((scope) => {
+    return managerRef.current?.getCheatSheet(scope);
+  }, []);
+  const getActiveScope = React.useCallback(() => {
+    return managerRef.current?.getActiveScope() ?? "";
+  }, []);
+  const disableAll = React.useCallback((scope) => {
+    managerRef.current?.disableAll(scope);
+    log(`Disabled all shortcuts${scope ? ` in scope "${scope}"` : ""}`);
+  }, []);
+  const enableAll = React.useCallback((scope) => {
+    managerRef.current?.enableAll(scope);
+    log(`Enabled all shortcuts${scope ? ` in scope "${scope}"` : ""}`);
+  }, []);
+  const setScope = React.useCallback((scope) => {
+    managerRef.current?.setActiveScope(scope);
+    log("Scope set to:", scope);
+  }, []);
+  const resetScope = React.useCallback(() => {
+    managerRef.current?.resetScope();
+    log("Reset scope");
+  }, []);
+  const getScopes = React.useCallback(() => {
+    return managerRef.current?.getScopes() ?? [];
+  }, []);
+  const isScopeActive = React.useCallback((scope) => {
+    return managerRef.current?.isScopeActive(scope);
+  }, []);
+  const onTyping = React.useCallback(
+    (callback) => {
+      managerRef.current?.onTyping(callback);
+    },
+    []
+  );
+  const popScope = React.useCallback(() => {
+    managerRef.current?.popScope();
+    log("Popped scope, active scope is:", managerRef.current?.getActiveScope());
+  }, []);
+  const pushScope = React.useCallback((scope) => {
+    managerRef.current?.pushScope(scope);
+    log("Pushed scope:", scope);
+  }, []);
+  const getScopeInfo = React.useCallback((scope) => {
+    return managerRef.current?.getScopesInfo(scope);
+  }, []);
+  const destroy = () => {
+    managerRef.current?.destroy();
+  };
+  const clear = () => {
+    managerRef.current?.clear();
+  };
+  return {
+    register,
+    unregister,
+    enable,
+    disable,
+    toggle,
+    setScope,
+    getCheatSheet,
+    destroy,
+    getScopeInfo,
+    getActiveScope,
+    popScope,
+    pushScope,
+    resetScope,
+    getScopes,
+    isScopeActive,
+    onTyping,
+    enableAll,
+    clear,
+    disableAll,
+    manager: managerRef.current
+  };
+};
+
+// src/Keybindy.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var Keybindy = ({
+  scope = "global",
+  shortcuts = [],
+  children,
+  disabled,
+  onShortcutFired,
+  logs = false
+}) => {
+  const { register, unregister, manager, pushScope, popScope, getScopes, setScope } = useKeybindy({
+    onShortcutFired,
+    logs
+  });
+  const prevScope = React2.useRef(null);
+  React2.useEffect(() => {
+    prevScope.current = manager.getActiveScope();
+    if (!getScopes()?.includes(scope)) {
+      pushScope(scope);
+    }
+    setScope(scope);
+    shortcuts.forEach(({ keys, handler, options }) => {
+      register(keys, handler, { ...options, scope });
+    });
+    if (disabled) {
+      manager.disableAll(scope);
+    }
+    return () => {
+      shortcuts.forEach(({ keys }) => {
+        if (Array.isArray(keys[0])) {
+          keys.forEach((key) => unregister(key, scope));
+        } else {
+          unregister(keys, scope);
+        }
+      });
+      popScope();
+    };
+  }, [scope, JSON.stringify(shortcuts)]);
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+
+// src/ShortcutLabel.tsx
+import React3 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ShortcutLabel = ({ keys, renderKey, style, ...props }) => {
+  const isMac = typeof navigator !== "undefined" && /Mac/.test(navigator.userAgent);
+  const defaultRenderKey = (key) => {
+    switch (key.toLowerCase()) {
+      case "meta":
+        return isMac ? "\u2318" : "Ctrl";
+      case "ctrl":
+        return "Ctrl";
+      case "shift":
+        return "\u21E7";
+      case "alt":
+        return isMac ? "\u2325" : "Alt";
+      case "enter":
+        return "\u21B5";
+      default:
+        return key.toUpperCase();
+    }
+  };
+  const rendered = renderKey ? keys.map((key, i) => /* @__PURE__ */ jsx2(React3.Fragment, { children: renderKey(key, i, keys) }, i)) : defaultRenderKey ? [keys.map((key) => defaultRenderKey(key)).join(" + ")] : [];
+  return /* @__PURE__ */ jsx2(
+    "kbd",
+    {
+      style: {
+        fontFamily: "monospace",
+        padding: "2.5px 5px",
+        border: "1px solid #cccccc2f",
+        backgroundColor: "#2e2e2e",
+        borderRadius: "4px",
+        userSelect: "none",
+        ...style
+      },
+      ...props,
+      children: rendered
+    }
+  );
+};
+export {
+  Keybindy,
+  ShortcutLabel,
+  useKeybindy
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keybindy/react",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Keybindy for React: Simple, scoped keyboard shortcuts that require little setup. designed to smoothly blend in with your React applications, allowing for robust keybinding functionality without the overhead.",
   "author": {
     "name": "PRASSamin",
@@ -27,9 +27,7 @@
     }
   },
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts",
-    "!dist/**/*.map",
+    "dist/**/*",
     "package.json",
     "LICENSE.md",
     "README.md"
@@ -53,7 +51,7 @@
   },
   "dependencies": {
     "react": "^19.1.0",
-    "@keybindy/core": "1.1.0"
+    "@keybindy/core": "1.1.1"
   },
   "scripts": {
     "format": "prettier --write \"src/**/*.{ts,tsx}\"",