lazy_hotkeys 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83d9da819a7a654425f85d5483735a7c3b39a9efe223ffeb745ff6cad2929237
+  data.tar.gz: a70db76d82d03af34cf84d8d98165a2106007ed27dc1d751e9258694f14af591
+SHA512:
+  metadata.gz: 90938fc72535c798f603c5b412be32cd5fc49e73125969fa77969f1016253c94bdb6e759918bc11718a9ab4c252d72f8366a65dd8fafd7cdeeb6e3abd2fce3b1
+  data.tar.gz: c3a164be79bad857716d4dc19ceecb422f5e141ea1d407192443130d6f6b16f7fa14ccac51cfc9a06cd56c3b6d4e4aa64231d0a3b1b78f2a0b8f5d154339185b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 QuarkOnRails
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,228 @@
+# Lazy Hotkeys for Lazy People
+
+**Stop writing JavaScript. Your keyboard already knows what to do.**
+
+Declarative keyboard shortcuts for Rails. Define hotkeys in your views, watch them work. No Stimulus controllers. No event listeners. No `addEventListener` for the 10,000th time.
+
+## Install
+
+**1. Add the gem:**
+
+```bash
+bundle add lazy_hotkeys
+```
+
+**2. Run the generator:**
+
+```bash
+gem "lazy_hotkeys", "~> 0.1"
+```
+
+This copies `lazy_hotkeys.js` to `app/javascript/`
+
+**3. Load it:**
+
+**Importmap:**
+```bash
+pin "lazy_hotkeys", to: "lazy_hotkeys.js"
+```
+
+Then import it:
+```javascript
+// app/javascript/application.js
+import "lazy_hotkeys"
+```
+
+**esbuild/rollup/webpack or Vite:**
+
+Import with relative path in your entry point:
+```javascript
+// app/javascript/application.js  (or entrypoints/application.js in Vite)
+import "./lazy_hotkeys"
+```
+
+Done. Hotkeys work now. (hopefully)
+
+---
+
+## 1. Hotkeys
+
+Press keys. Things happen. Stop pretending you like writing JavaScript.
+
+### Navigate Somewhere
+
+```erb
+<%= hotkey("g i", visit: "/inbox") %>
+<%= hotkey("ctrl+n", visit: new_post_path) %>
+```
+
+Press `g` then `i`. You're in your inbox. Magic? No. Just less suffering.
+
+### Send a Request
+
+```erb
+<%= hotkey("ctrl+s", to: "/save", method: :post) %>
+<%= hotkey("ctrl+d", to: post_path(@post), method: :delete) %>
+```
+
+Ctrl+S sends a POST. Ctrl+D deletes. Your mouse is crying. Good.
+
+### Dispatch an Action
+
+```erb
+<%= hotkey("ctrl+k", action: "open-command-palette") %>
+```
+
+```javascript
+// Some Stimulus controller, somewhere
+document.addEventListener('lazy-hotkeys:action', (e) => {
+  if (e.detail.action === 'open-command-palette') {
+    this.open();
+  }
+});
+```
+
+For when you absolutely must write JavaScript.
+
+### Chain Multiple Actions
+
+```erb
+<%= hotkey("ctrl+s", chain: [
+  { type: "dom", target: "#status", set_text: "Saving..." },
+  { type: "request", to: "/save", method: "post" },
+  { type: "dom", target: "#status", set_text: "Saved!" }
+]) %>
+```
+
+One key. Multiple actions. Sequential.
+
+---
+
+## 2. DOM Manipulation
+
+### Show/Hide Things
+
+```erb
+<%= hotkey("?", dom: { target: "#help", toggle_class: "hidden" }) %>
+<%= hotkey("esc", dom: { target: ".modal", add_class: "hidden" }) %>
+<%= hotkey("ctrl+h", dom: { target: "#sidebar", remove_class: "collapsed" }) %>
+```
+
+### Change Text
+
+```erb
+<%= hotkey("ctrl+shift+c", dom: {
+  target: "#counter",
+  set_text: "9999"
+}) %>
+```
+
+### Click Things
+
+```erb
+<%= hotkey("ctrl+enter", dom: { target: "form button", click: true }) %>
+<%= hotkey("/", dom: { target: "#search-input", focus: true }) %>
+```
+
+Your hands never leave the keyboard. Your mouse collects dust. Evolution.
+
+### Set Attributes
+
+```erb
+<%= hotkey("ctrl+d", dom: { target: "#mode", set_attr: { "data-theme": "dark" }}) %>
+```
+
+### Use a Template (For more complex HTML)
+
+```erb
+<%= hotkey("ctrl+p", dom: { target: "#preview", replace_with: "template" }) do %>
+  <div class="preview-panel">
+    <h3>Preview</h3>
+    <p>Your content here</p>
+  </div>
+<% end %>
+```
+
+Press the key. The template replaces the target. No `innerHTML`. No XSS. Just works.
+
+---
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `visit: "/path"` | Navigate to URL (Turbo or regular) |
+| `to: "/endpoint"` | Send request (GET/POST/PATCH/DELETE) |
+| `method: :post` | HTTP method (with `to:`) |
+| `params: { ... }` | Request params (with `to:`) |
+| `action: "name"` | Dispatch custom event |
+| `dom: { ... }` | Manipulate DOM (see below) |
+| `chain: [...]` | Multiple actions in sequence |
+| `scope: "#form"` | Only works when element exists |
+| `prevent_default: false` | Allow browser default (default: true) |
+| `same_origin: false` | Allow cross-origin (default: true) |
+| `hint: "Save"` | Tooltip/hint text |
+
+### DOM Options
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `target: "#id"` | CSS selector | Required |
+| `click: true` | Click the element | `{ target: "button", click: true }` |
+| `focus: true` | Focus the element | `{ target: "input", focus: true }` |
+| `set_text: "..."` | Change text (safe) | `{ target: "#status", set_text: "Done" }` |
+| `add_class: "..."` | Add CSS class | `{ target: "#box", add_class: "active" }` |
+| `remove_class: "..."` | Remove CSS class | `{ target: "#box", remove_class: "hidden" }` |
+| `toggle_class: "..."` | Toggle CSS class | `{ target: "#menu", toggle_class: "open" }` |
+| `set_attr: { k: v }` | Set attributes (whitelisted) | `{ target: "#mode", set_attr: { "data-theme": "dark" } }` |
+| `remove_attr: "..."` | Remove attribute | `{ target: "#input", remove_attr: "disabled" }` |
+| `replace_with: "template"` | Replace with template content | See template example above |
+
+### Cross-Origin
+
+By default, requests to other domains are blocked:
+
+```erb
+<%# This works %>
+<%= hotkey("ctrl+s", to: "/save") %>
+
+<%# This is blocked %>
+<%= hotkey("ctrl+x", to: "https://github.com/Plan-Vert/open-letter") %>
+
+<%# This works (you asked for it) %>
+<%= hotkey("?", visit: "https://discord.gg/BUtwjJTwxt", same_origin: false) %>
+```
+
+`javascript:`, `data:`, and `file:` URLs are always blocked, even with `same_origin: false`.
+
+**Attribute whitelist:**
+Check `lazy_hotkeys.js` and adjust attribute whitelist to your needs, define only what you need.
+---
+
+## Config
+
+Minimal config at the top of `lazy_hotkeys.js`:
+
+```javascript
+const CFG = {
+    normalizeCmdToCtrl: true, // Cmd on Mac = Ctrl on Windows
+    skipInInputs: true, // Don't fire when typing in inputs
+    sequenceTimeoutMs: 800 // How long to wait for sequences like "g i"
+};
+```
+
+Change these values directly in the file. That's it.
+
+---
+
+## Requirements
+
+Rails 5.1+ (needs `tag.template` helper)
+
+---
+
+## License
+
+MIT
+
+---

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+task default: :build

data/lib/generators/lazy_hotkeys/install/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require "rails/generators"
+
+module LazyHotkeys
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      class_option :path, type: :string, default: "app/javascript/lazy_hotkeys.js",
+                   desc: "Where to place the JS file (use app/assets/javascripts/... for sprockets)"
+
+      def copy_js_runtime
+        template "lazy_hotkeys.js", options[:path]
+      end
+
+      def say_next_steps
+        say <<~MSG
+          Added lazy_hotkeys JS runtime at #{options[:path]}.
+          Ensure it's loaded on the page (Importmap pin or pack include).
+        MSG
+      end
+    end
+  end
+end

data/lib/generators/lazy_hotkeys/install/templates/lazy_hotkeys.js

@@ -0,0 +1,248 @@
+// Scans <template data-hotkey ...> generated by "hotkey" helpers and installs key handlers.
+
+(function () {
+    if (window.LazyHotkeys) return; // avoid double-boot
+
+    // Config,
+    const CFG = {
+        normalizeCmdToCtrl: true,
+        skipInInputs: true,
+        sequenceTimeoutMs: 800
+    };
+
+    // Utils
+    function isTyping(el) {
+        if (!CFG.skipInInputs) return false;
+        if (!el || !el.closest) return false;
+        return !!el.closest("input, textarea, [contenteditable]");
+    }
+
+    // Normalize printable vs named keys
+    function keyName(e) {
+        const k = e.key.length === 1 ? e.key.toLowerCase() : e.key.toLowerCase();
+        return k === " " ? "space" : k;
+    }
+
+    function metaOrCtrl(e) {
+        return (CFG.normalizeCmdToCtrl && (e.metaKey || e.ctrlKey)) || e.ctrlKey;
+    }
+
+    function eventToCombo(e) {
+        const parts = [];
+        if (metaOrCtrl(e)) parts.push("ctrl");
+        if (e.shiftKey) parts.push("shift");
+        if (e.altKey) parts.push("alt");
+        const k = keyName(e);
+        if (!["control", "shift", "alt", "meta"].includes(k)) parts.push(k);
+        return parts.join("+");
+    }
+
+    function parseJSON(s) {
+        try { return s ? JSON.parse(s) : null; } catch (_) { return null; }
+    }
+
+    function toArray(v) { return Array.isArray(v) ? v : [v]; }
+
+    function isSafeAttribute(name) {
+        const safePrefixes = ["data-", "aria-"];
+        const safeAttributes = [
+            "class", "id", "title", "lang", "dir",
+            "role", "tabindex", "alt",
+            "name", "value", "type", "for", "placeholder", "autocomplete", "autofocus",
+            "checked", "selected", "disabled", "readonly", "required", "multiple",
+            "maxlength", "minlength", "max", "min", "step", "pattern", "size",
+            "accept", "cols", "rows", "wrap", "spellcheck",
+            "hidden", "draggable"
+        ];
+
+        const lowerName = name.toLowerCase();
+
+        if (safeAttributes.includes(lowerName)) return true;
+        if (safePrefixes.some(prefix => lowerName.startsWith(prefix))) return true;
+
+        return false;
+    }
+
+    function isSafeUrl(url, allowCrossOrigin) {
+        try {
+            const u = new URL(url, location.href);
+            if (u.protocol !== "http:" && u.protocol !== "https:") { return false; }
+            if (!allowCrossOrigin && (u.origin !== location.origin)) { return false; }
+
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    // Combos like "g i"
+    let sequence = [];
+    let seqTimer = null;
+    function pushSequence(key) {
+        if (seqTimer) clearTimeout(seqTimer);
+        sequence.push(key);
+        seqTimer = setTimeout(() => { sequence = []; }, CFG.sequenceTimeoutMs);
+        return sequence.join(" ");
+    }
+
+    // Fetch helpers
+    function csrfToken() {
+        return document.querySelector("meta[name=csrf-token]")?.content || null;
+    }
+
+    async function request(def, allowCrossOrigin) {
+        if (!isSafeUrl(def.to, allowCrossOrigin)) return;
+
+        const method = (def.method || "GET").toUpperCase();
+        const headers = {
+            "Accept": "text/vnd.turbo-stream.html, text/html, application/json"
+        };
+
+        let body;
+        if (!["GET", "HEAD"].includes(method)) {
+            headers["Content-Type"] = "application/json";
+            const token = csrfToken();
+            if (token) headers["X-CSRF-Token"] = token;
+            body = JSON.stringify(def.params || {});
+        }
+
+        const res = await fetch(def.to, { method, headers, body });
+        const ct = (res.headers.get("Content-Type") || "").toLowerCase();
+        if (res.ok && ct.includes("turbo-stream")) {
+            const html = await res.text();
+            document.documentElement.insertAdjacentHTML("beforeend", html);
+        }
+        return res;
+    }
+
+    function visit(url, allowCrossOrigin) {
+        if (!isSafeUrl(url, allowCrossOrigin)) return;
+        if (window.Turbo && typeof Turbo.visit === "function") Turbo.visit(url);
+        else window.location.href = url;
+    }
+
+    // Sends a document-level event other controllers can catch.
+
+    function dispatchAction(action) {
+        const evt = new CustomEvent("lazy-hotkeys:action", { detail: { action } });
+        document.dispatchEvent(evt);
+    }
+
+    // DOM operations
+    function performDom(def, tplEl) {
+        const el = document.querySelector(def.target);
+        if (!el) return;
+
+        if (def.add_class) el.classList.add(...toArray(def.add_class));
+        if (def.remove_class) el.classList.remove(...toArray(def.remove_class));
+        if (def.toggle_class) el.classList.toggle(def.toggle_class);
+
+        if (def.set_attr) Object.entries(def.set_attr).forEach(([k, v]) => { if (isSafeAttribute(k)) el.setAttribute(k, String(v)); });
+        if (def.remove_attr) toArray(def.remove_attr).forEach((k) => el.removeAttribute(k));
+
+        if (def.set_text != null) el.textContent = String(def.set_text);
+
+        if (def.replace_with === "template" && tplEl) {
+            el.innerHTML = "";
+            el.append(tplEl.content.cloneNode(true));
+        }
+
+        if (def.focus) el.focus();
+        if (def.click) el.click();
+    }
+
+    // --- Def parsing ---
+    function parseDefs() {
+        const els = document.querySelectorAll("[data-hotkey='true']");
+        const defs = [];
+        els.forEach((el) => {
+            const type = el.dataset.hotkeyType;            // "visit"|"request"|"action"|"dom"|"chain"
+            const opts = parseJSON(el.dataset.hotkeyOpts) || {};
+            defs.push({
+                el,
+                keys: (el.dataset.hotkeyKeys || "").toLowerCase(),
+                type,
+                prevent: el.dataset.hotkeyPrevent === "true",
+                sameOrigin: el.dataset.hotkeySameOrigin !== "false",
+                scope: el.dataset.hotkeyScope,
+                hint: el.dataset.hotkeyHint,
+                opts
+            });
+        });
+        return defs;
+    }
+
+    function inScope(def) {
+        if (!def.scope) return true;
+        return !!document.querySelector(def.scope);
+    }
+
+    // --- Registry & handlers ---
+    const registry = new Map(); // "ctrl+s" or "g i" -> def
+
+    function register(def) {
+        registry.set(def.keys, def);
+    }
+
+    function bootScan() {
+        registry.clear();
+        parseDefs().forEach(register);
+    }
+
+    async function handle(def) {
+        const opts = def.opts || {};
+        const allowCrossOrigin = !def.sameOrigin;
+        switch (def.type) {
+            case "visit":
+                visit(opts.to, allowCrossOrigin);
+                break;
+            case "request":
+                await request(opts, allowCrossOrigin);
+                break;
+            case "action":
+                dispatchAction(opts.action);
+                break;
+            case "dom":
+                performDom(opts, def.el);
+                break;
+            case "chain":
+                for (const step of opts) {
+                    if (step.type === "dom") performDom(step, def.el);
+                    else if (step.type === "visit") visit(step.to, allowCrossOrigin);
+                    else if (step.type === "request") await request(step, allowCrossOrigin);
+                    else if (step.type === "action") dispatchAction(step.action);
+                }
+                break;
+        }
+    }
+
+    function onKeydown(e) {
+        if (isTyping(e.target)) return;
+
+        const comboKey = eventToCombo(e);    // e.g., "ctrl+s"
+        const seq = pushSequence(comboKey);  // e.g., "g i" after two presses
+
+        const def = registry.get(seq) || registry.get(comboKey);
+        if (!def) return;
+
+        if (!inScope(def)) return;
+        if (def.prevent) e.preventDefault();
+
+        handle(def);
+    }
+
+    function boot() {
+        bootScan();
+        document.addEventListener("keydown", onKeydown);
+
+        // Re-scan after Turbo visits
+        document.addEventListener("turbo:load", bootScan);
+    }
+
+    window.LazyHotkeys = { boot };
+    if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", boot);
+    } else {
+        boot();
+    }
+})();

data/lib/lazy_hotkeys/hotkeys_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LazyHotkeys
+  module HotkeysHelper
+    def hotkey(keys, **opts, &block)
+      type, payload =
+        if opts[:visit]
+          [:visit, { to: opts[:visit] }]
+        elsif opts[:to]
+          [:request, { to: opts[:to], method: (opts[:method] || :get).to_s.upcase, params: opts[:params] }]
+        elsif opts[:action]
+          [:action, { action: opts[:action].to_s }]
+        elsif opts[:dom]
+          [:dom, opts[:dom]]
+        elsif opts[:chain]
+          [:chain, opts[:chain]]
+        else
+          raise ArgumentError, "Specify one of: visit:, to:, action:, dom:, chain:"
+        end
+
+      data = {
+        "data-hotkey" => "true",
+        "data-hotkey-keys" => keys,
+        "data-hotkey-type" => type,
+        "data-hotkey-opts" => payload.to_json,
+        "data-hotkey-scope" => opts[:scope],
+        "data-hotkey-prevent" => (opts.key?(:prevent_default) ? opts[:prevent_default] : true).to_s,
+        "data-hotkey-same-origin" => (opts.key?(:same_origin) ? opts[:same_origin] : true).to_s,
+        "data-hotkey-hint" => opts[:hint]
+      }.compact
+
+      content = capture(&block) if block_given?
+      tag.template(content, **data)
+    end
+  end
+end

data/lib/lazy_hotkeys/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require "rails/railtie"
+
+module LazyHotkeys
+  class Railtie < ::Rails::Railtie
+    initializer "lazy_hotkeys.view_helper" do
+      ActiveSupport.on_load(:action_view) do
+        require_relative "hotkeys_helper"
+        include LazyHotkeys::HotkeysHelper
+      end
+    end
+  end
+end

data/lib/lazy_hotkeys/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LazyHotkeys
+  VERSION = "0.1.0"
+end

data/lib/lazy_hotkeys.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require_relative "lazy_hotkeys/version"
+require_relative "lazy_hotkeys/railtie" if defined?(Rails)
+
+module LazyHotkeys
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: lazy_hotkeys
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- QuarkXZ
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Define hotkey events in views, trigger visit/request/client actions,
+  and simple DOM mutations without boilerplate JS.
+email:
+- quarkXZ@proton.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/lazy_hotkeys/install/install_generator.rb
+- lib/generators/lazy_hotkeys/install/templates/lazy_hotkeys.js
+- lib/lazy_hotkeys.rb
+- lib/lazy_hotkeys/hotkeys_helper.rb
+- lib/lazy_hotkeys/railtie.rb
+- lib/lazy_hotkeys/version.rb
+homepage: https://github.com/you/lazy_hotkeys
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/you/lazy_hotkeys
+post_install_message: |2+
+
+  ⚡ LazyHotkeys installed!
+
+  Run: rails generate lazy_hotkeys:install
+
+  Then add to your importmap or JS bundler:
+    # Importmap
+    bin/importmap pin lazy_hotkeys
+
+    # Or require in your JavaScript entry point like application.js
+    import "lazy_hotkeys"
+
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Declarative keyboard shortcuts for Rails (Turbo/Stimulus-friendly).
+test_files: []