chore(repo): baseline du fork input-remapper (upstream v2.2.1)

Le dépôt ne contenait que README.md ; ajout de l'intégralité du code
fonctionnel du fork comme socle stable de la branche de release.
L'état runtime d'orchestration (.ideai/) est exclu du suivi.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

inputremapper/injection/macros/tasks/mod_tap.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# input-remapper - GUI for device specific keyboard mappings
+# Copyright (C) 2025 sezanzeb <b8x45ygc9@mozmail.com>
+#
+# This file is part of input-remapper.
+#
+# input-remapper is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# input-remapper is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with input-remapper.  If not, see <https://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from typing import Deque
+
+from evdev.ecodes import EV_KEY
+
+from inputremapper.configs.keyboard_layout import keyboard_layout
+from inputremapper.injection.macros.argument import ArgumentConfig
+from inputremapper.injection.macros.task import Task
+from inputremapper.input_event import InputEvent
+from inputremapper.logging.logger import logger
+
+
+class ModTapTask(Task):
+    """If pressed long enough in combination with other keys, it turns into a modifier.
+
+    Can be used to make home-row-modifiers.
+
+    Works similar to the default of
+    https://github.com/qmk/qmk_firmware/blob/78a0adfbb4d2c4e12f93f2a62ded0020d406243e/docs/tap_hold.md#comparison-comparison
+    """
+
+    argument_configs = [
+        ArgumentConfig(
+            name="default",
+            position=0,
+            types=[str],
+            is_symbol=True,
+        ),
+        ArgumentConfig(
+            name="modifier",
+            position=1,
+            types=[str],
+            is_symbol=True,
+        ),
+        ArgumentConfig(
+            name="tapping_term",
+            position=2,
+            types=[int, float],
+            default=200,
+        ),
+    ]
+
+    async def run(self, callback) -> None:
+        tapping_term = self.get_argument("tapping_term").get_value() / 1000
+        jamming_asyncio_events: Deque[asyncio.Event] = deque()
+
+        async def listener(event: InputEvent) -> None:
+            trigger = self.mapping.input_combination[-1]
+            if event.type_and_code == trigger.type_and_code:
+                # We don't block the event that would set _trigger_release_event.
+                return
+
+            if event.type != EV_KEY:
+                return
+
+            asyncio_event = asyncio.Event()
+            jamming_asyncio_events.append(asyncio_event)
+            # Make the EventReader wait until the mod_tap macro allows it to continue
+            # processing the event. Because we want to wait until mod_tap injected the
+            # modifier.
+            await asyncio_event.wait()
+
+        self.add_event_listener(listener)
+
+        timeout = asyncio.Task(asyncio.sleep(tapping_term))
+        await asyncio.wait(
+            [asyncio.Task(self._trigger_release_event.wait()), timeout],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        has_timed_out = timeout.done()
+
+        if has_timed_out:
+            # The timeout happened before the trigger got released.
+            # We therefore modify stuff.
+            symbol = self.get_argument("modifier").get_value()
+            logger.debug("Modifying with %s", symbol)
+        else:
+            # The trigger got released before the timeout.
+            # We therefore do not modify stuff.
+            symbol = self.get_argument("default").get_value()
+            logger.debug("Writing default %s", symbol)
+
+        code = keyboard_layout.get(symbol)
+        callback(EV_KEY, code, 1)
+        await self.keycode_pause()
+
+        # Now that we know if the key was pressed with the intention of modifying other
+        # keys, we can let the jammed keys go on their journey through the handlers.
+        # Those other handlers may map them to other keys and stuff.
+        while len(jamming_asyncio_events) > 0:
+            asyncio_event = jamming_asyncio_events.popleft()
+            asyncio_event.set()
+            await self.keycode_pause()
+            await self.throttle()
+            # While we are emptying the queue, more events might still arrive and add
+            # to the queue.
+
+        # We remove this as late as possible, because if more keys are pressed while
+        # jamming_asyncio_events is still being taken care of, they should wait until
+        # all is done. This ensures the order of all events that are pressed, until
+        # mod_tap is completely finished.
+        self.remove_event_listener(listener)
+
+        # Keep the modifier pressed until the input/trigger is released
+        await self._trigger_release_event.wait()
+        callback(EV_KEY, code, 0)
+
+        await self.keycode_pause()
+
+    async def throttle(self) -> None:
+        # In case the keycode_pause ist set to 0ms, we need to give the event handlers
+        # a chance to inject the withheld events, before we go on. This ensures the
+        # correct order of injections. Since we are using asyncio, something like
+        # `callback(EV_KEY, code, 0)` might be faster than the event handlers, even if
+        # it is the last step of the macro.
+        if self.mapping.macro_key_sleep_ms == 0:
+            await asyncio.sleep(0.01)