@k37z3r/jbase 2.0.0

package/dist/modules/events/binding.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * @file src/modules/events/binding.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Core event binding methods (on, off, trigger). Handles event registration and removal.
+ * * 🇩🇪: Kern-Methoden für Event-Binding (on, off, trigger). Behandelt die Registrierung und Entfernung von Events.
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.on = on;
+exports.off = off;
+/**
+ * * 🇬🇧: Registers an event listener for all elements in the current selection. Uses the native `addEventListener` method internally.
+ * * 🇩🇪: Registriert einen Event-Listener für alle Elemente in der aktuellen Auswahl. Nutzt intern die native `addEventListener`-Methode.
+ * @param event
+ * * 🇬🇧: The name of the event (e.g., 'click', 'mouseenter').
+ * * 🇩🇪: Der Name des Events (z.B. 'click', 'mouseenter').
+ * @param handler
+ * * 🇬🇧: The callback function to execute when the event triggers.
+ * * 🇩🇪: Die Callback-Funktion, die beim Auslösen des Events ausgeführt wird.
+ * @returns
+ * * 🇬🇧: The jBase instance for method chaining.
+ * * 🇩🇪: Die jBase-Instanz für Method-Chaining.
+ */
+function on(event, handler) {
+    this.forEach(el => {
+        el.addEventListener(event, handler);
+    });
+    return this;
+}
+/**
+ * * 🇬🇧: Removes a previously registered event listener from all elements in the current selection. Uses the native `removeEventListener` method internally.
+ * Note: The handler passed must be the exact same reference used in `on`.
+ * * 🇩🇪: Entfernt einen zuvor registrierten Event-Listener von allen Elementen in der aktuellen Auswahl. Nutzt intern die native `removeEventListener`-Methode.
+ * Hinweis: Der übergebene Handler muss exakt dieselbe Referenz sein, die bei `on` verwendet wurde.
+ * @param event
+ * * 🇬🇧: The name of the event.
+ * * 🇩🇪: Der Name des Events.
+ * @param handler
+ * * 🇬🇧: The reference of the callback function to remove.
+ * * 🇩🇪: Die Referenz der Callback-Funktion, die entfernt werden soll.
+ * @returns
+ * * 🇬🇧: The jBase instance for method chaining.
+ * * 🇩🇪: Die jBase-Instanz für Method-Chaining.
+ */
+function off(event, handler) {
+    this.forEach(el => {
+        el.removeEventListener(event, handler);
+    });
+    return this;
+}
+//# sourceMappingURL=binding.js.map

package/dist/modules/events/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../../src/modules/events/binding.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAiBH,gBAKC;AAiBD,kBAKC;AAxCD;;;;;;;;;;;;GAYG;AACH,SAAgB,EAAE,CAAc,KAAa,EAAE,OAA2C;IACtF,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;QACd,EAAE,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,GAAG,CAAc,KAAa,EAAE,OAA2C;IACvF,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;QACd,EAAE,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IACH,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/modules/events/form.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @file src/modules/events/form.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling form events (submit, change, focus, blur, input).
+ * * 🇩🇪: Methoden zur Behandlung von Formular-Events (submit, change, focus, blur, input).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+import { jBase } from '../../core';
+/**
+ * * 🇬🇧: Registers an event handler for the 'submit' event. Triggered when a form is submitted.
+ * * 🇩🇪: Registriert einen Event-Handler für das 'submit'-Event. Wird ausgelöst, wenn ein Formular abgesendet wird.
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+export declare function submit(this: jBase, handler: (event: SubmitEvent) => void): jBase;
+/**
+ * * 🇬🇧: Registers an event handler for the 'change' event. Triggered when the value of an element (<input>, <select>, <textarea>) is changed by the user and committed (e.g., on blur).
+ * * 🇩🇪: Registriert einen Event-Handler für das 'change'-Event. Wird ausgelöst, wenn der Wert eines Elements (<input>, <select>, <textarea>) geändert und bestätigt wurde (z.B. durch Verlassen).
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+export declare function change(this: jBase, handler: (event: Event) => void): jBase;
+/**
+ * * 🇬🇧: Registers an event handler for the 'input' event. Triggered immediately when the value changes (real-time, e.g., every keystroke).
+ * * 🇩🇪: Registriert einen Event-Handler für das 'input'-Event. Wird sofort ausgelöst, wenn sich der Wert ändert (Echtzeit, z.B. bei jedem Tastenanschlag).
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+export declare function input(this: jBase, handler: (event: Event) => void): jBase;
+/**
+ * * 🇬🇧: Handles the 'focus' event. If a handler is provided, it binds the listener. If no handler is provided, it programmatically sets focus on the element(s).
+ * * 🇩🇪: Behandelt das 'focus'-Event. Wenn ein Handler übergeben wird, wird der Listener gebunden. Ohne Handler wird der Fokus programmatisch auf das/die Element(e) gesetzt.
+ * @param handler
+ * * 🇬🇧: (Optional) The function to execute when the event occurs.
+ * * 🇩🇪: (Optional) Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+export declare function focus(this: jBase, handler?: (event: FocusEvent) => void): jBase;
+/**
+ * * 🇬🇧: Handles the 'blur' event (element loses focus). If a handler is provided, it binds the listener. If no handler is provided, it programmatically removes focus.
+ * * 🇩🇪: Behandelt das 'blur'-Event (Verlust des Fokus). Wenn ein Handler übergeben wird, wird der Listener gebunden. Ohne Handler wird der Fokus programmatisch entfernt.
+ * @param handler
+ * * 🇬🇧: (Optional) The function to execute when the event occurs.
+ * * 🇩🇪: (Optional) Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+export declare function blur(this: jBase, handler?: (event: FocusEvent) => void): jBase;
+//# sourceMappingURL=form.d.ts.map

package/dist/modules/events/form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.d.ts","sourceRoot":"","sources":["../../../src/modules/events/form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,KAAK,CAEhF;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,CAE1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,CAEzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,KAAK,CAS/E;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,KAAK,CAS9E"}

package/dist/modules/events/form.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * @file src/modules/events/form.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling form events (submit, change, focus, blur, input).
+ * * 🇩🇪: Methoden zur Behandlung von Formular-Events (submit, change, focus, blur, input).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submit = submit;
+exports.change = change;
+exports.input = input;
+exports.focus = focus;
+exports.blur = blur;
+/**
+ * * 🇬🇧: Registers an event handler for the 'submit' event. Triggered when a form is submitted.
+ * * 🇩🇪: Registriert einen Event-Handler für das 'submit'-Event. Wird ausgelöst, wenn ein Formular abgesendet wird.
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+function submit(handler) {
+    return this.on('submit', handler);
+}
+/**
+ * * 🇬🇧: Registers an event handler for the 'change' event. Triggered when the value of an element (<input>, <select>, <textarea>) is changed by the user and committed (e.g., on blur).
+ * * 🇩🇪: Registriert einen Event-Handler für das 'change'-Event. Wird ausgelöst, wenn der Wert eines Elements (<input>, <select>, <textarea>) geändert und bestätigt wurde (z.B. durch Verlassen).
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+function change(handler) {
+    return this.on('change', handler);
+}
+/**
+ * * 🇬🇧: Registers an event handler for the 'input' event. Triggered immediately when the value changes (real-time, e.g., every keystroke).
+ * * 🇩🇪: Registriert einen Event-Handler für das 'input'-Event. Wird sofort ausgelöst, wenn sich der Wert ändert (Echtzeit, z.B. bei jedem Tastenanschlag).
+ * @param handler
+ * * 🇬🇧: The function to execute when the event occurs.
+ * * 🇩🇪: Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+function input(handler) {
+    return this.on('input', handler);
+}
+/**
+ * * 🇬🇧: Handles the 'focus' event. If a handler is provided, it binds the listener. If no handler is provided, it programmatically sets focus on the element(s).
+ * * 🇩🇪: Behandelt das 'focus'-Event. Wenn ein Handler übergeben wird, wird der Listener gebunden. Ohne Handler wird der Fokus programmatisch auf das/die Element(e) gesetzt.
+ * @param handler
+ * * 🇬🇧: (Optional) The function to execute when the event occurs.
+ * * 🇩🇪: (Optional) Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+function focus(handler) {
+    if (handler) {
+        return this.on('focus', handler);
+    }
+    else {
+        this.forEach(el => {
+            if (el instanceof HTMLElement)
+                el.focus();
+        });
+        return this;
+    }
+}
+/**
+ * * 🇬🇧: Handles the 'blur' event (element loses focus). If a handler is provided, it binds the listener. If no handler is provided, it programmatically removes focus.
+ * * 🇩🇪: Behandelt das 'blur'-Event (Verlust des Fokus). Wenn ein Handler übergeben wird, wird der Listener gebunden. Ohne Handler wird der Fokus programmatisch entfernt.
+ * @param handler
+ * * 🇬🇧: (Optional) The function to execute when the event occurs.
+ * * 🇩🇪: (Optional) Die Funktion, die ausgeführt wird, wenn das Event eintritt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Chaining.
+ */
+function blur(handler) {
+    if (handler) {
+        return this.on('blur', handler);
+    }
+    else {
+        this.forEach(el => {
+            if (el instanceof HTMLElement)
+                el.blur();
+        });
+        return this;
+    }
+}
+//# sourceMappingURL=form.js.map

package/dist/modules/events/form.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.js","sourceRoot":"","sources":["../../../src/modules/events/form.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAcH,wBAEC;AAYD,wBAEC;AAYD,sBAEC;AAYD,sBASC;AAYD,oBASC;AAlFD;;;;;;;;;GASG;AACH,SAAgB,MAAM,CAAc,OAAqC;IACrE,OAAO,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,MAAM,CAAc,OAA+B;IAC/D,OAAO,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,KAAK,CAAc,OAA+B;IAC9D,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,KAAK,CAAc,OAAqC;IACpE,IAAI,OAAO,EAAE,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAwB,CAAC,CAAC;IACtD,CAAC;SAAM,CAAC;QACJ,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YACd,IAAI,EAAE,YAAY,WAAW;gBAAE,EAAE,CAAC,KAAK,EAAE,CAAC;QAC9C,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,IAAI,CAAc,OAAqC;IACnE,IAAI,OAAO,EAAE,CAAC;QACV,OAAO,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,OAAwB,CAAC,CAAC;IACrD,CAAC;SAAM,CAAC;QACJ,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YACd,IAAI,EAAE,YAAY,WAAW;gBAAE,EAAE,CAAC,IAAI,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC"}

package/dist/modules/events/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @file src/modules/events/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Central entry point for event handling. Aggregates binding, mouse, lifecycle, keyboard, form, and touch events.
+ * * 🇩🇪: Zentraler Einstiegspunkt für Event-Handling. Aggregiert Binding-, Maus-, Lebenszyklus-, Tastatur-, Formular- und Touch-Events.
+ * @requires ./binding
+ * * 🇬🇧: General event binding (on, off).
+ * * 🇩🇪: Generelle Event-Bindung (on, off).
+ * @requires ./mouse
+ * * 🇬🇧: Mouse interaction events (click, hover, etc.).
+ * * 🇩🇪: Maus-Interaktions-Events (click, hover, etc.).
+ * @requires ./lifecycle
+ * * 🇬🇧: DOM lifecycle events (ready).
+ * * 🇩🇪: DOM-Lebenszyklus-Events (ready).
+ * @requires ./keyboard
+ * * 🇬🇧: Keyboard interaction events (keydown, keyup).
+ * * 🇩🇪: Tastatur-Interaktions-Events (keydown, keyup).
+ * @requires ./form
+ * * 🇬🇧: Form handling events (submit, change, input).
+ * * 🇩🇪: Formular-Verarbeitungs-Events (submit, change, input).
+ * @requires ./touch
+ * * 🇬🇧: Touch interaction events.
+ * * 🇩🇪: Touch-Interaktions-Events.
+ */
+/**
+ * * 🇬🇧: Aggregated object of all event methods. Combines logic from various sub-modules into a single object. Used to extend the `jBase` prototype via `Object.assign`.
+ * * 🇩🇪: Aggregiertes Objekt aller Event-Methoden. Vereint die Logik aus verschiedenen Sub-Modulen in einem einzigen Objekt. Wird genutzt, um den Prototypen der `jBase`-Klasse via `Object.assign` zu erweitern.
+ */
+export declare const eventMethods: {
+    touchstart(this: import("../..").JBaseClass, handler: (event: TouchEvent) => void): import("../..").JBaseClass;
+    touchend(this: import("../..").JBaseClass, handler: (event: TouchEvent) => void): import("../..").JBaseClass;
+    touchmove(this: import("../..").JBaseClass, handler: (event: TouchEvent) => void): import("../..").JBaseClass;
+    touchcancel(this: import("../..").JBaseClass, handler: (event: TouchEvent) => void): import("../..").JBaseClass;
+    submit(this: import("../..").JBaseClass, handler: (event: SubmitEvent) => void): import("../..").JBaseClass;
+    change(this: import("../..").JBaseClass, handler: (event: Event) => void): import("../..").JBaseClass;
+    input(this: import("../..").JBaseClass, handler: (event: Event) => void): import("../..").JBaseClass;
+    focus(this: import("../..").JBaseClass, handler?: (event: FocusEvent) => void): import("../..").JBaseClass;
+    blur(this: import("../..").JBaseClass, handler?: (event: FocusEvent) => void): import("../..").JBaseClass;
+    keydown(this: import("../..").JBaseClass, handler: (event: KeyboardEvent) => void): import("../..").JBaseClass;
+    keyup(this: import("../..").JBaseClass, handler: (event: KeyboardEvent) => void): import("../..").JBaseClass;
+    keypress(this: import("../..").JBaseClass, handler: (event: KeyboardEvent) => void): import("../..").JBaseClass;
+    pressedKey(this: import("../..").JBaseClass, targetKey: string, handler: (event: KeyboardEvent) => void): import("../..").JBaseClass;
+    ready(this: import("../..").JBaseClass, handler: () => void): import("../..").JBaseClass;
+    click(this: import("../..").JBaseClass, handler?: (event: Event) => void): import("../..").JBaseClass;
+    mousemove(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mouseleave(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mouseenter(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mousedown(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mouseup(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    dblclick(this: import("../..").JBaseClass, handler?: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mouseout(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    mouseover(this: import("../..").JBaseClass, handler: (event: MouseEvent) => void): import("../..").JBaseClass;
+    on(this: import("../..").JBaseClass, event: string, handler: EventListenerOrEventListenerObject): import("../..").JBaseClass;
+    off(this: import("../..").JBaseClass, event: string, handler: EventListenerOrEventListenerObject): import("../..").JBaseClass;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AASH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;CAOxB,CAAC"}

package/dist/modules/events/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * @file src/modules/events/index.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Central entry point for event handling. Aggregates binding, mouse, lifecycle, keyboard, form, and touch events.
+ * * 🇩🇪: Zentraler Einstiegspunkt für Event-Handling. Aggregiert Binding-, Maus-, Lebenszyklus-, Tastatur-, Formular- und Touch-Events.
+ * @requires ./binding
+ * * 🇬🇧: General event binding (on, off).
+ * * 🇩🇪: Generelle Event-Bindung (on, off).
+ * @requires ./mouse
+ * * 🇬🇧: Mouse interaction events (click, hover, etc.).
+ * * 🇩🇪: Maus-Interaktions-Events (click, hover, etc.).
+ * @requires ./lifecycle
+ * * 🇬🇧: DOM lifecycle events (ready).
+ * * 🇩🇪: DOM-Lebenszyklus-Events (ready).
+ * @requires ./keyboard
+ * * 🇬🇧: Keyboard interaction events (keydown, keyup).
+ * * 🇩🇪: Tastatur-Interaktions-Events (keydown, keyup).
+ * @requires ./form
+ * * 🇬🇧: Form handling events (submit, change, input).
+ * * 🇩🇪: Formular-Verarbeitungs-Events (submit, change, input).
+ * @requires ./touch
+ * * 🇬🇧: Touch interaction events.
+ * * 🇩🇪: Touch-Interaktions-Events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventMethods = void 0;
+const tslib_1 = require("tslib");
+const bindingMethods = tslib_1.__importStar(require("./binding"));
+const mouseMethods = tslib_1.__importStar(require("./mouse"));
+const lifecycleMethods = tslib_1.__importStar(require("./lifecycle"));
+const keyboardMethods = tslib_1.__importStar(require("./keyboard"));
+const formMethods = tslib_1.__importStar(require("./form"));
+const touchMethods = tslib_1.__importStar(require("./touch"));
+/**
+ * * 🇬🇧: Aggregated object of all event methods. Combines logic from various sub-modules into a single object. Used to extend the `jBase` prototype via `Object.assign`.
+ * * 🇩🇪: Aggregiertes Objekt aller Event-Methoden. Vereint die Logik aus verschiedenen Sub-Modulen in einem einzigen Objekt. Wird genutzt, um den Prototypen der `jBase`-Klasse via `Object.assign` zu erweitern.
+ */
+exports.eventMethods = {
+    ...bindingMethods,
+    ...mouseMethods,
+    ...lifecycleMethods,
+    ...keyboardMethods,
+    ...formMethods,
+    ...touchMethods
+};
+//# sourceMappingURL=index.js.map

package/dist/modules/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/modules/events/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;;;;AAEH,kEAA4C;AAC5C,8DAAwC;AACxC,sEAAgD;AAChD,oEAA8C;AAC9C,4DAAsC;AACtC,8DAAwC;AAExC;;;GAGG;AACU,QAAA,YAAY,GAAG;IACxB,GAAG,cAAc;IACjB,GAAG,YAAY;IACf,GAAG,gBAAgB;IACnB,GAAG,eAAe;IAClB,GAAG,WAAW;IACd,GAAG,YAAY;CAClB,CAAC"}

package/dist/modules/events/keyboard.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @file src/modules/events/keyboard.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling keyboard events (keydown, keyup, keypress).
+ * * 🇩🇪: Methoden zur Behandlung von Tastatur-Events (keydown, keyup, keypress).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+import { jBase } from '../../core';
+/**
+ * * 🇬🇧: Binds an event handler to the 'keydown' event. Fires immediately when a key is pressed (repeats if held).
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keydown'-Event. Feuert sofort, wenn eine Taste gedrückt wird (und wiederholt, wenn gehalten).
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+export declare function keydown(this: jBase, handler: (event: KeyboardEvent) => void): jBase;
+/**
+ * * 🇬🇧: Binds an event handler to the 'keyup' event. Fires when a key is released.
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keyup'-Event. Feuert, wenn eine Taste losgelassen wird.
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+export declare function keyup(this: jBase, handler: (event: KeyboardEvent) => void): jBase;
+/**
+ * * 🇬🇧: Binds an event handler to the 'keypress' event. Deprecated in modern standards.
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keypress'-Event. In modernen Standards veraltet (deprecated).
+ * @deprecated Use keydown or input instead.
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+export declare function keypress(this: jBase, handler: (event: KeyboardEvent) => void): jBase;
+/**
+ * * 🇬🇧: Binds an event handler for a specific key (case-insensitive).
+ * * 🇩🇪: Bindet einen Event-Handler für eine spezifische Taste (Groß-/Kleinschreibung wird ignoriert).
+ * @param targetKey
+ * * 🇬🇧: The key to react to (e.g., 'm', 'Enter', 'Escape').
+ * * 🇩🇪: Die Taste, auf die reagiert werden soll (z.B. 'm', 'Enter', 'Escape').
+ * @param handler
+ * * 🇬🇧: The callback function.
+ * * 🇩🇪: Die Callback-Funktion.
+ * @returns
+ * * 🇬🇧: The current jBase instance.
+ * * 🇩🇪: Die aktuelle jBase-Instanz.
+ */
+export declare function pressedKey(this: jBase, targetKey: string, handler: (event: KeyboardEvent) => void): jBase;
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/modules/events/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../../../src/modules/events/keyboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,KAAK,CAEnF;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,KAAK,CAEjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,KAAK,CAEpF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,KAAK,CAOzG"}

package/dist/modules/events/keyboard.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * @file src/modules/events/keyboard.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling keyboard events (keydown, keyup, keypress).
+ * * 🇩🇪: Methoden zur Behandlung von Tastatur-Events (keydown, keyup, keypress).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keydown = keydown;
+exports.keyup = keyup;
+exports.keypress = keypress;
+exports.pressedKey = pressedKey;
+/**
+ * * 🇬🇧: Binds an event handler to the 'keydown' event. Fires immediately when a key is pressed (repeats if held).
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keydown'-Event. Feuert sofort, wenn eine Taste gedrückt wird (und wiederholt, wenn gehalten).
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+function keydown(handler) {
+    return this.on('keydown', handler);
+}
+/**
+ * * 🇬🇧: Binds an event handler to the 'keyup' event. Fires when a key is released.
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keyup'-Event. Feuert, wenn eine Taste losgelassen wird.
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+function keyup(handler) {
+    return this.on('keyup', handler);
+}
+/**
+ * * 🇬🇧: Binds an event handler to the 'keypress' event. Deprecated in modern standards.
+ * * 🇩🇪: Bindet einen Event-Handler an das 'keypress'-Event. In modernen Standards veraltet (deprecated).
+ * @deprecated Use keydown or input instead.
+ * @param handler
+ * * 🇬🇧: The callback function receiving the KeyboardEvent.
+ * * 🇩🇪: Die Callback-Funktion, die das KeyboardEvent empfängt.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+function keypress(handler) {
+    return this.on('keypress', handler);
+}
+/**
+ * * 🇬🇧: Binds an event handler for a specific key (case-insensitive).
+ * * 🇩🇪: Bindet einen Event-Handler für eine spezifische Taste (Groß-/Kleinschreibung wird ignoriert).
+ * @param targetKey
+ * * 🇬🇧: The key to react to (e.g., 'm', 'Enter', 'Escape').
+ * * 🇩🇪: Die Taste, auf die reagiert werden soll (z.B. 'm', 'Enter', 'Escape').
+ * @param handler
+ * * 🇬🇧: The callback function.
+ * * 🇩🇪: Die Callback-Funktion.
+ * @returns
+ * * 🇬🇧: The current jBase instance.
+ * * 🇩🇪: Die aktuelle jBase-Instanz.
+ */
+function pressedKey(targetKey, handler) {
+    return this.on('keydown', (e) => {
+        const event = e;
+        if (event.key.toLowerCase() === targetKey.toLowerCase()) {
+            handler(event);
+        }
+    });
+}
+//# sourceMappingURL=keyboard.js.map

package/dist/modules/events/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sourceRoot":"","sources":["../../../src/modules/events/keyboard.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAcH,0BAEC;AAYD,sBAEC;AAaD,4BAEC;AAeD,gCAOC;AA/DD;;;;;;;;;GASG;AACH,SAAgB,OAAO,CAAc,OAAuC;IACxE,OAAO,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,OAAwB,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,KAAK,CAAc,OAAuC;IACtE,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,QAAQ,CAAc,OAAuC;IACzE,OAAO,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,OAAwB,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CAAc,SAAiB,EAAE,OAAuC;IAC9F,OAAO,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,CAAQ,EAAE,EAAE;QACnC,MAAM,KAAK,GAAG,CAAkB,CAAC;QACjC,IAAI,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,SAAS,CAAC,WAAW,EAAE,EAAE,CAAC;YACtD,OAAO,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC;IACL,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/modules/events/lifecycle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file src/modules/events/lifecycle.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling DOM lifecycle events (e.g., ready).
+ * * 🇩🇪: Methoden zur Behandlung von DOM-Lebenszyklus-Events (z.B. ready).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+import { jBase } from '../../core';
+/**
+ * * 🇬🇧: Executes the handler as soon as the DOM is fully loaded and parsed. If the document is already ready (readyState 'interactive' or 'complete'), the handler executes immediately to avoid race conditions.
+ * * 🇩🇪: Führt den übergebenen Handler aus, sobald das DOM vollständig geladen und geparst ist. Falls das Dokument bereits bereit ist (readyState 'interactive' oder 'complete'), wird der Handler sofort ausgeführt, um Race Conditions zu vermeiden.
+ * @param handler
+ * * 🇬🇧: The callback function to execute when the DOM is ready.
+ * * 🇩🇪: Die Callback-Funktion, die ausgeführt werden soll, sobald das DOM bereit ist.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+export declare function ready(this: jBase, handler: () => void): jBase;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/modules/events/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/modules/events/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,KAAK,CAS7D"}

package/dist/modules/events/lifecycle.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * @file src/modules/events/lifecycle.ts
+ * @version 2.0.0
+ * @since 2.0.0
+ * @license GPL-3.0-or-later
+ * @copyright Sven Minio 2026
+ * @author Sven Minio <https://sven-minio.de>
+ * @category Events
+ * @description
+ * * 🇬🇧: Methods for handling DOM lifecycle events (e.g., ready).
+ * * 🇩🇪: Methoden zur Behandlung von DOM-Lebenszyklus-Events (z.B. ready).
+ * @requires ../../core
+ * * 🇬🇧: Depends on the core jBase class for type definitions.
+ * * 🇩🇪: Hängt von der Core-jBase-Klasse für Typ-Definitionen ab.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ready = ready;
+/**
+ * * 🇬🇧: Executes the handler as soon as the DOM is fully loaded and parsed. If the document is already ready (readyState 'interactive' or 'complete'), the handler executes immediately to avoid race conditions.
+ * * 🇩🇪: Führt den übergebenen Handler aus, sobald das DOM vollständig geladen und geparst ist. Falls das Dokument bereits bereit ist (readyState 'interactive' oder 'complete'), wird der Handler sofort ausgeführt, um Race Conditions zu vermeiden.
+ * @param handler
+ * * 🇬🇧: The callback function to execute when the DOM is ready.
+ * * 🇩🇪: Die Callback-Funktion, die ausgeführt werden soll, sobald das DOM bereit ist.
+ * @returns
+ * * 🇬🇧: The current jBase instance for method chaining.
+ * * 🇩🇪: Die aktuelle jBase-Instanz für Method-Chaining.
+ */
+function ready(handler) {
+    // Check if DOM is already ready (no waiting required)
+    if (document.readyState === 'complete' || document.readyState === 'interactive') {
+        handler();
+    }
+    else {
+        // Register event listener if DOM is still loading
+        this.on('DOMContentLoaded', handler);
+    }
+    return this;
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/modules/events/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../../src/modules/events/lifecycle.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAcH,sBASC;AAnBD;;;;;;;;;GASG;AACH,SAAgB,KAAK,CAAc,OAAmB;IAClD,sDAAsD;IACtD,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,IAAI,QAAQ,CAAC,UAAU,KAAK,aAAa,EAAE,CAAC;QAC9E,OAAO,EAAE,CAAC;IACd,CAAC;SAAM,CAAC;QACJ,kDAAkD;QAClD,IAAI,CAAC,EAAE,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC"}