tiny-essentials 1.22.2 → 1.22.4

package/docs/v1/libs/TinyEvents.md

@@ -1,199 +1,187 @@
-# 📦 TinyEvents
+# 📢 TinyEvents Documentation
 
-A **lightweight event emitter** class similar to Node.js's `EventEmitter`, written in modern JavaScript with no dependencies. Perfect for publish/subscribe patterns in modular apps.
+TinyEvents is a lightweight, dependency-free **event emitter system**, inspired by Node.js’s `EventEmitter`.
+It allows components to **subscribe**, **emit**, and **manage** events and their listeners in a clean and modular way.
 
 ---
 
-## 🧠 What is TinyEvents?
+## ✨ Features
 
-`TinyEvents` enables your components or modules to **subscribe to**, **emit**, and **manage custom events**.
-
-It supports:
-
-* 🔁 Persistent listeners (`on`, `appendListener`, `prependListener`)
-* 🔂 One-time listeners (`once`, `appendListenerOnce`, `prependListenerOnce`)
-* 📤 Emitting events (`emit`)
-* 🔍 Inspecting listeners (`listenerCount`, `listeners`, `onceListeners`, `allListeners`, `eventNames`)
-* 🧹 Removing listeners (`off`, `offAll`, `offAllTypes`)
-* 🚦 Controlling listener count (`setMaxListeners`, `getMaxListeners`)
+* ➕ Add/remove event listeners (`on`, `off`, `offAll`, `offAllTypes`)
+* 🔂 One-time listeners (`once`, `prependListenerOnce`)
+* 📢 Emit events (`emit`)
+* 🔍 Inspect listeners (`listenerCount`, `listeners`, `onceListeners`, `allListeners`, `eventNames`)
+* ⚖️ Control maximum listeners (`setMaxListeners`, `getMaxListeners`)
+* 🚨 Configurable error/warning when max listeners exceeded (`setThrowOnMaxListeners`)
 
 ---
 
-## 🔧 API Reference
-
-### `on(event: string, handler: function): void`
+## 📚 API Reference
 
-Adds a listener for the specified event.
+### 🔹 Event Handler Callback
 
-```js
-emitter.on('hello', (name) => console.log(`Hi, ${name}`));
+```ts
+/**
+ * A generic event listener callback function.
+ *
+ * @callback handler
+ * @param {...any} payload - The data payload passed when the event is triggered.
+ * @returns {void}
+ */
 ```
 
 ---
 
-### `once(event: string, handler: function): function`
+### 🏗️ Class: `TinyEvents`
 
-Adds a one-time listener that is automatically removed after it runs once.
+#### 🔒 Private Properties
 
-```js
-emitter.once('data', console.log);
-```
+* `#listeners: Map<string, { handler: handler, config: { once: boolean } }[]>` – Stores registered listeners
+* `#maxListeners: number` – Maximum allowed listeners per event (default: `10`)
+* `#throwMaxListeners: boolean` – Whether to throw error or only warn when max is exceeded
 
 ---
 
-### `appendListener(event: string, handler: function): void`
+### ⚙️ Configuration
 
-Alias for `on()`.
+#### `setThrowOnMaxListeners(shouldThrow: boolean): void`
 
----
+Enable/disable throwing an error when max listeners is exceeded.
 
-### `appendListenerOnce(event: string, handler: function): function`
-
-Alias for `once()`.
+* ✅ `true`: throws error
+* ⚠️ `false`: logs warning
 
 ---
 
-### `prependListener(event: string, handler: function): void`
+#### `getThrowOnMaxListeners(): boolean`
 
-Adds a listener to the **start** of the listener array (called before others).
+Check if exceeding the listener limit will throw an error or just warn.
 
 ---
 
-### `prependListenerOnce(event: string, handler: function): function`
-
-Adds a one-time listener to the **start** of the listener array.
+#### `setMaxListeners(n: number): void`
 
----
+Set the maximum number of listeners per event.
 
-### `emit(event: string, ...payload: any[]): boolean`
+* Must be a non-negative integer.
 
-Calls all listeners for an event, passing any number of arguments.
+---
 
-Returns `true` if any listeners were called, otherwise `false`.
+#### `getMaxListeners(): number`
 
-```js
-emitter.emit('greet', 'Yasmin', 21);
-```
+Get the maximum number of listeners allowed per event.
 
 ---
 
-### `off(event: string, handler: function): void`
-
-Removes a specific listener from an event.
+### ➕ Adding Listeners
 
----
+#### `on(event: string|string[], handler: handler): void`
 
-### `offAll(event: string): void`
+Registers an event listener.
 
-Removes **all listeners** for a specific event.
+#### `once(event: string|string[], handler: handler): handler[]`
 
----
+Registers a one-time event listener that is removed after being triggered once.
 
-### `offAllTypes(): void`
+#### `appendListener(event: string|string[], handler: handler): void`
 
-Clears **all listeners** from **all events**.
+Alias for `.on()`.
 
----
+#### `appendListenerOnce(event: string|string[], handler: handler): handler[]`
 
-### `listenerCount(event: string): number`
+Alias for `.once()`.
 
-Returns how many listeners are currently registered for the event.
+#### `prependListener(event: string|string[], handler: handler): void`
 
----
+Registers a listener at the **beginning** of the listeners array.
 
-### `listeners(event: string): function[]`
+#### `prependListenerOnce(event: string|string[], handler: handler): handler[]`
 
-Returns an array of **non-once** listener functions for an event.
+Registers a one-time listener at the **beginning** of the listeners array.
 
 ---
 
-### `onceListeners(event: string): function[]`
+### ❌ Removing Listeners
 
-Returns an array of **once-only** listener functions for an event.
+#### `off(event: string|string[], handler: handler): void`
 
----
+Removes a specific listener from an event.
 
-### `allListeners(event: string): function[]`
+#### `offAll(event: string|string[]): void`
 
-Returns all listeners, including wrapped `once()` functions.
+Removes all listeners for one or more events.
 
----
+#### `offAllTypes(): void`
 
-### `eventNames(): string[]`
-
-Returns an array of event names that currently have listeners.
+Removes **all listeners** for **all events**.
 
 ---
 
-### `setMaxListeners(n: number): void`
+### 📢 Emitting Events
 
-Sets the maximum allowed listeners per event. Shows a warning if exceeded.
+#### `emit(event: string|string[], ...payload: any[]): boolean[]`
 
----
+Emits one or more events with optional payload.
 
-### `getMaxListeners(): number`
+* Returns an array of booleans:
 
-Returns the current max listener limit (default: 10).
+  * `true` if listeners were called
+  * `false` if no listeners were registered
 
 ---
 
-### `setThrowOnMaxListeners(shouldThrow: boolean): void`
+### 🔍 Inspecting Listeners
 
-Enables or disables the behavior of throwing an error when the number of listeners exceeds the maximum limit.
+#### `listenerCount(event: string): number`
 
-* If `true`, the class will **throw an error** instead of just logging a warning.
-* If `false`, it will default to console warning (default behavior).
+Get the number of listeners for a given event.
 
-#### Parameters:
+#### `listeners(event: string): handler[]`
 
-* `shouldThrow` *(boolean)* – Whether to throw an error when the listener limit is exceeded.
+Get all listeners registered for an event (excluding `once`).
 
----
+#### `onceListeners(event: string): handler[]`
+
+Get only listeners registered with `.once()`.
 
-### `getThrowOnMaxListeners(): boolean`
+#### `allListeners(event: string): handler[]`
 
-Returns whether the emitter is currently set to throw an error when the maximum number of listeners is exceeded.
+Get all listeners, including internal wrappers (e.g. from `.once()`).
 
-#### Returns:
+#### `eventNames(): string[]`
 
-* *(boolean)* – `true` if error throwing is enabled, otherwise `false`.
+Get a list of all registered event names.
 
 ---
 
-## 🧪 Example
+## 📝 Example Usage
 
 ```js
 import TinyEvents from './TinyEvents.js';
 
-const emitter = new TinyEvents();
+const events = new TinyEvents();
 
-function greet(name) {
-  console.log(`👋 Hello, ${name}`);
-}
+// Add listener
+events.on('data', (msg) => console.log('Received:', msg));
 
-emitter.on('greet', greet);
-emitter.emit('greet', 'Yasmin'); // "👋 Hello, Yasmin"
-emitter.off('greet', greet);
-```
+// Add once listener
+events.once(['ready', 'init'], () => console.log('Initialized!'));
 
----
+// Emit events
+events.emit('data', 'Hello World');
+events.emit(['ready', 'init']);
 
-## 🛡️ Type Definitions
+// Check listeners
+console.log(events.listenerCount('data')); // 1
 
-```ts
-/**
- * A generic event listener callback function.
- * @callback handler
- * @param {...any} payload - Arguments passed when event is emitted.
- * @returns {void}
- */
+// Remove all listeners
+events.offAll('data');
 ```
 
 ---
 
-## ✅ Why Use It?
+## ⚡ Notes
 
-* No dependencies
-* Fully typed (with JSDoc)
-* Inspired by Node.js EventEmitter
-* Works in browser or Node
+* Supports both **single string events** (`"data"`) and **arrays of events** (`["ready", "init"]`) 🚀
+* Helps prevent memory leaks with `setMaxListeners` and warning/error system 🛑
+* Perfect for **frontend components**, **Node.js scripts**, and **custom event-driven modules** 🧩

package/docs/v1/libs/TinyHtml.md

@@ -935,7 +935,7 @@ Extracts a single DOM element from the internal list at the specified index.
 
 ---
 
-### `getAll()`
+### `get elements`
 Returns the current targets held by this instance.
 
 - **Returns**: `ConstructorElValues[]`
@@ -2081,11 +2081,13 @@ Safe and type-checked — throws if misuse is detected.
 
 ---
 
-### 🧲 `.hasProp()` / `.addProp()` / `.removeProp()` / `.toggleProp()`
+### 🧲 `.hasProp()` / `.addProp()` / `.removeProp()` / `.toggleProp()` / `.prop()` / `.setProp()`
 
 Properties
 
 ```js
+element.prop('scrollHeight');           // get scrollHeight value
+element.setProp('disabled', true);      // set true
 element.hasProp("disabled");            // true/false
 element.addProp("checked");             // set true
 element.removeProp("checked");          // set false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-essentials",
-  "version": "1.22.2",
+  "version": "1.22.4",
   "description": "Collection of small, essential scripts designed to be used across various projects. These simple utilities are crafted for speed, ease of use, and versatility.",
   "scripts": {
     "test": "npm run test:mjs && npm run test:cjs && npm run test:js",