@alwatr/action 9.14.0 → 9.16.0

package/README.md

@@ -2,7 +2,7 @@
 
 **Declarative DOM action-dispatch — the Action layer for Unidirectional Data Flow.**
 
-`@alwatr/action` bridges HTML `on-action` attributes to typed signal handlers using **global event delegation**. One listener on `document.body` covers every element on the page — including elements added dynamically after bootstrap — with O(1) initialization cost regardless of how many elements exist.
+`@alwatr/action` bridges HTML `on-<eventType>` attributes to typed signal handlers using **global event delegation**. One listener on `document.body` covers every element on the page — including elements added dynamically after bootstrap — with O(1) initialization cost regardless of how many elements exist.
 
 ---
 
@@ -25,7 +25,7 @@ The action bus is powered by a [`ChannelSignal`](../signal/README.md) from `@alw
 
 ### Global Event Delegation
 
-A single capture-phase listener on `document.body` handles all `on-action` elements. When an event fires, the handler walks up from `event.target` using `closest('[on-action]')`, parses the attribute, runs modifiers, resolves the payload, and dispatches the action.
+A single capture-phase listener on `document.body` handles all `on-<eventType>` elements. When an event fires, the handler walks up from `event.target` using `closest('[on-click]')` (or the matching attribute), parses the attribute value, runs modifiers, resolves the payload, and dispatches the action.
 
 ```
 User clicks a button
@@ -33,13 +33,13 @@ User clicks a button
         ▼
 document.body capture listener  (1 listener per event type)
         │
-        └─ closest('[on-action^=click]') → finds element
-           parse attribute → 'click->add-to-cart:42'
+        └─ closest('[on-click]') → finds element
+           parse attribute → 'add_to_cart:42'
            run modifiers   → none
            resolve payload → '42'
-           internalChannel_.dispatch('add-to-cart', '42')
+           internalChannel_.dispatch('add_to_cart', '42')
                 │
-                └─ Map.get('add-to-cart') → O(1) → invoke only matching handlers
+                └─ Map.get('add_to_cart') → O(1) → invoke only matching handlers
 ```
 
 ### Complexity
@@ -53,7 +53,7 @@ document.body capture listener  (1 listener per event type)
 
 ### `once` modifier
 
-In delegation mode, `once` is implemented by removing the `on-action` attribute from the element after the first fire. This is simpler than a `WeakSet` cache and naturally handles element reuse — if the element is re-rendered with the attribute, it fires again.
+In delegation mode, `once` is implemented by removing the `on-<eventType>` attribute from the element after the first fire. This is simpler than a `WeakSet` cache and naturally handles element reuse — if the element is re-rendered with the attribute, it fires again.
 
 ---
 
@@ -77,10 +77,10 @@ Extend `ActionRecord` via declaration merging. This gives you full type safety a
 // src/action-record.ts
 declare module '@alwatr/action' {
   interface ActionRecord {
-    'open-drawer': string;
-    'search-query': string;
-    'add-to-cart': {productId: number; qty: number};
-    'logout': void;
+    open_drawer: string;
+    search_query: string;
+    add_to_cart: {productId: number; qty: number};
+    logout: void;
   }
 }
 ```
@@ -94,8 +94,8 @@ import './action-record.js'; // ensure the declaration is loaded
 setupActionDelegation();
 
 // Payload types are inferred from ActionRecord — no generics needed.
-onAction('open-drawer', (panel) => openDrawer(panel)); // panel: string
-onAction('add-to-cart', (item) => {
+onAction('open_drawer', (panel) => openDrawer(panel)); // panel: string
+onAction('add_to_cart', (item) => {
   cartService.add(item.productId, item.qty); // fully typed
 });
 ```
@@ -103,19 +103,22 @@ onAction('add-to-cart', (item) => {
 ### 3. Add attributes to HTML
 
 ```html
-<!-- Dispatches 'open-drawer' with payload 'main' on click -->
-<button on-action="click->open-drawer:main">Open Drawer</button>
+<!-- Dispatches 'close_drawer' on click — no payload -->
+<button on-click="close_drawer">Close</button>
 
-<!-- Dispatches 'search-query' with the input's live value -->
+<!-- Dispatches 'open_drawer' with payload 'main' on click -->
+<button on-click="open_drawer:main">Open Drawer</button>
+
+<!-- Dispatches 'search_query' with the input's live value -->
 <input
   type="search"
-  on-action="input->search-query:$value"
+  on-input="search_query:$value"
   placeholder="Search…"
 />
 
 <!-- Prevents default, validates, then dispatches all field values -->
 <form
-  on-action="submit.prevent.validate->submit-form:$formdata"
+  on-submit="submit_form:$formdata; prevent,validate"
   novalidate
 >
   <input
@@ -126,7 +129,7 @@ onAction('add-to-cart', (item) => {
 </form>
 
 <!-- Fires only once — attribute is removed after first click -->
-<button on-action="click.once->welcome-dismissed">Got it</button>
+<button on-click="welcome_dismissed; once">Got it</button>
 ```
 
 ### 4. Programmatic dispatch
@@ -135,7 +138,7 @@ onAction('add-to-cart', (item) => {
 import {dispatchAction} from '@alwatr/action';
 
 await uploadFile(file);
-dispatchAction('upload-complete', fileId);
+dispatchAction('upload_complete', fileId);
 
 dispatchAction('navigate', '/dashboard');
 ```
@@ -145,23 +148,23 @@ dispatchAction('navigate', '/dashboard');
 ## Attribute Syntax
 
 ```
-on-action="eventType[.modifier…]->actionId[:payload]"
+on-<eventType>="actionId[:payload][; modifier1,modifier2,…]"
 ```
 
-| Segment     | Description                                               | Example                       |
-| ----------- | --------------------------------------------------------- | ----------------------------- |
-| `eventType` | Any standard DOM event name                               | `click`, `input`, `submit`    |
-| `modifier`  | Optional dot-chained tokens processed before dispatch     | `.prevent`, `.validate`       |
-| `actionId`  | Identifier your handler subscribes to                     | `open-drawer`, `search-query` |
-| `:payload`  | Optional literal string, or a `$`-prefixed resolver token | `:main`, `:$value`            |
+| Segment       | Description                                                 | Example                       |
+| ------------- | ----------------------------------------------------------- | ----------------------------- |
+| `eventType`   | Any standard DOM event name — encoded in the attribute name | `on-click`, `on-submit`       |
+| `actionId`    | Identifier your handler subscribes to                       | `open_drawer`, `search_query` |
+| `:payload`    | Optional literal string, or a `$`-prefixed resolver token   | `:main`, `:$value`            |
+| `; modifiers` | Optional comma-separated modifier list after a semicolon    | `; prevent,validate`          |
 
 ### Built-in modifiers
 
-| Modifier    | Behavior                                                                         |
-| ----------- | -------------------------------------------------------------------------------- |
-| `.prevent`  | Calls `event.preventDefault()`                                                   |
-| `.once`     | Removes the `on-action` attribute after first fire — action dispatches only once |
-| `.validate` | Cancels dispatch if the nearest `<form>` fails `checkValidity()`                 |
+| Modifier   | Behavior                                                                              |
+| ---------- | ------------------------------------------------------------------------------------- |
+| `prevent`  | Calls `event.preventDefault()`                                                        |
+| `once`     | Removes the `on-<eventType>` attribute after first fire — action dispatches only once |
+| `validate` | Cancels dispatch if the nearest `<form>` fails `checkValidity()`                      |
 
 ### Built-in payload resolvers
 
@@ -181,8 +184,8 @@ The global action type registry. Extend via declaration merging to register type
 ```ts
 declare module '@alwatr/action' {
   interface ActionRecord {
-    'open-drawer': string;
-    'logout': void;
+    open_drawer: string;
+    logout: void;
   }
 }
 ```
@@ -229,7 +232,7 @@ function onAction<K extends keyof ActionRecord>(
 ```
 
 ```ts
-const sub = onAction('open-drawer', (panel) => openDrawer(panel));
+const sub = onAction('open_drawer', (panel) => openDrawer(panel));
 sub.unsubscribe(); // prevent memory leaks
 ```
 
@@ -241,7 +244,7 @@ Dispatches a named action. Payload type is enforced by `ActionRecord`.
 
 ```ts
 // With payload
-dispatchAction('open-drawer', 'settings');
+dispatchAction('open_drawer', 'settings');
 
 // Void payload — no second argument
 dispatchAction('logout');
@@ -258,15 +261,14 @@ Handler signature: `(event: Event, element: HTMLElement) => boolean`
 ```ts
 import {registerModifier} from '@alwatr/action';
 
-// Arrow function — no `this` binding needed
-registerModifier('not-disabled', (_event, element) => {
+registerModifier('not_disabled', (_event, element) => {
   return !(element as HTMLButtonElement).disabled;
 });
 ```
 
 ```html
 <button
-  on-action="click.not-disabled->select-item:$data-id"
+  on-click="select_item:$data_id; not_disabled"
   data-id="42"
 >
   Select
@@ -288,7 +290,7 @@ registerPayloadResolver('$checked', (_event, element) => {
   return (element as HTMLInputElement).checked;
 });
 
-registerPayloadResolver('$data-id', (_event, element) => {
+registerPayloadResolver('$data_id', (_event, element) => {
   return (element as HTMLElement).dataset.id ?? null;
 });
 ```
@@ -296,10 +298,10 @@ registerPayloadResolver('$data-id', (_event, element) => {
 ```html
 <input
   type="checkbox"
-  on-action="change->toggle-feature:$checked"
+  on-change="toggle_feature:$checked"
 />
 <li
-  on-action="click->select-item:$data-id"
+  on-click="select_item:$data_id"
   data-id="42"
 >
   Item
@@ -311,33 +313,33 @@ registerPayloadResolver('$data-id', (_event, element) => {
 ## Unidirectional Data Flow
 
 ```
-┌─────────────────────────────────────────────────────────┐
-│                        UI Layer                         │
-│  <button on-action="click->add-to-cart:42">Add</button> │
-└────────────────────────┬────────────────────────────────┘
-                         │ DOM event bubbles to body
-                         ▼
-┌─────────────────────────────────────────────────────────┐
-│              Action Layer (@alwatr/action)               │
-│  document.body capture listener (1 per event type)      │
-│  → closest('[on-action]') → parse → modifiers           │
-│  → internalChannel_.dispatch('add-to-cart', '42') [O(1)]│
-└────────────────────────┬────────────────────────────────┘
-                         │ O(1) routing via ChannelSignal
-                         ▼
-┌─────────────────────────────────────────────────────────┐
-│                   Business Logic Layer                  │
-│  onAction('add-to-cart', (id) => cartService.add(id))   │
-└────────────────────────┬────────────────────────────────┘
-                         │ state update
-                         ▼
-┌─────────────────────────────────────────────────────────┐
-│                    State Layer (@alwatr/signal)          │
-│  cartSignal.set(newCartState)                           │
-└────────────────────────┬────────────────────────────────┘
-                         │ state flows down to UI
-                         ▼
-                      UI re-renders
+┌──────────────────────────────────────────────────────────┐
+│                         UI Layer                         │
+│  <button on-click="add_to_cart:42">Add</button>          │
+└─────────────────────────┬────────────────────────────────┘
+                          │ DOM event bubbles to body
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│               Action Layer (@alwatr/action)              │
+│  document.body capture listener (1 per event type)       │
+│  → closest('[on-click]') → parse → modifiers             │
+│  → internalChannel_.dispatch('add_to_cart', '42') [O(1)] │
+└─────────────────────────┬────────────────────────────────┘
+                          │ O(1) routing via ChannelSignal
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│                    Business Logic Layer                  │
+│  onAction('add_to_cart', (id) => cartService.add(id))    │
+└─────────────────────────┬────────────────────────────────┘
+                          │ state update
+                          ▼
+┌──────────────────────────────────────────────────────────┐
+│                 State Layer (@alwatr/signal)              │
+│  cartSignal.set(newCartState)                            │
+└─────────────────────────┬────────────────────────────────┘
+                          │ state flows down to UI
+                          ▼
+                       UI re-renders
 ```
 
 ---
@@ -353,6 +355,36 @@ concern, not a user-interaction action.
 
 ## Migration from Previous Versions
 
+### Attribute syntax changed
+
+The event type is now encoded in the **attribute name** instead of the value, and modifiers are listed after a semicolon instead of dot-chained before the arrow.
+
+**Before:**
+
+```html
+<button on-action="click->open_drawer:main">Open</button>
+<form
+  on-action="submit.prevent.validate->submit_form:$formdata"
+  novalidate
+>
+  …
+</form>
+<button on-action="click.once->welcome_dismissed">Got it</button>
+```
+
+**After:**
+
+```html
+<button on-click="open_drawer:main">Open</button>
+<form
+  on-submit="submit_form:$formdata; prevent,validate"
+  novalidate
+>
+  …
+</form>
+<button on-click="welcome_dismissed; once">Got it</button>
+```
+
 ### `ActionContext` removed
 
 The `this` context in modifier and resolver handlers changed to explicit parameters:
@@ -360,7 +392,7 @@ The `this` context in modifier and resolver handlers changed to explicit paramet
 **Before:**
 
 ```ts
-registerModifier('not-disabled', function () {
+registerModifier('not_disabled', function () {
   return !(this.element as HTMLButtonElement).disabled;
 });
 ```
@@ -368,22 +400,51 @@ registerModifier('not-disabled', function () {
 **After:**
 
 ```ts
-registerModifier('not-disabled', (_event, element) => {
+registerModifier('not_disabled', (_event, element) => {
   return !(element as HTMLButtonElement).disabled;
 });
 ```
 
-### `once` behavior changed
-
-Previously tracked via `WeakSet`. Now removes the `on-action` attribute after first fire.
-Behavior is equivalent for typical use cases.
-
 ### `page-ready` moved to `@alwatr/page-ready`
 
 `dispatchPageId` / `onPageReady` are no longer part of this package.
 
 ---
 
+---
+
+## 🌊 Part of Alwatr Flux
+
+`@alwatr/action` is the **Action Layer** of the [Alwatr Flux](https://github.com/Alwatr/alwatr/tree/next/pkg/flux) architecture — a complete Unidirectional Data Flow system for building scalable Progressive Web Applications.
+
+```
+View (HTML on-<event> attributes)
+  ↓
+Action Layer (@alwatr/action) — global delegation, O(1) routing
+  ↓
+Controller (business logic via onAction)
+  ↓
+State Layer (@alwatr/signal) — fine-grained reactivity
+  ↓
+View (re-render only affected nodes)
+```
+
+`@alwatr/action` is the bridge between the **View** and **Controller** layers. It captures user intent from HTML attributes and routes it to the right handler — without any coupling between the UI and business logic.
+
+**The full Flux bundle** (`@alwatr/flux`) includes actions, signals, directives, page-ready, and storage — everything you need to build a complete reactive application from a single import.
+
+```typescript
+// Use @alwatr/flux for the complete architecture
+import {setupActionDelegation, onAction, createStateSignal} from '@alwatr/flux';
+
+// Or use @alwatr/action standalone for just the action bus
+import {setupActionDelegation, onAction, dispatchAction} from '@alwatr/action';
+```
+
+→ [View the complete Flux documentation](https://github.com/Alwatr/alwatr/tree/next/pkg/flux)
+
+---
+
 ## Contributing
 
 Contributions are welcome! Please read our [contribution guidelines](https://github.com/Alwatr/.github/blob/next/CONTRIBUTING.md) before submitting a pull request.

package/dist/action-record.d.ts

@@ -13,8 +13,8 @@
  * // In your package: src/action-record.ts
  * declare module '@alwatr/action' {
  *   interface ActionRecord {
- *     'open-drawer': string;
- *     'add-to-cart': {productId: number; qty: number};
+ *     'open_drawer': string;
+ *     'add_to_cart': {productId: number; qty: number};
  *     'logout': void;
  *   }
  * }
@@ -42,8 +42,8 @@
  * // pkg/my-feature/src/action-record.ts
  * declare module '@alwatr/action' {
  *   interface ActionRecord {
- *     'open-drawer': string;
- *     'add-to-cart': {productId: number; qty: number};
+ *     'open_drawer': string;
+ *     'add_to_cart': {productId: number; qty: number};
  *     'logout': void;
  *   }
  * }

package/dist/delegate.d.ts

@@ -10,12 +10,12 @@
  * time — O(N) initialization cost, O(N) memory for listener references, and
  * zero support for elements added after bootstrap.
  *
- * This module implements the **Qwik-inspired global delegation** pattern:
+ * This module implements the global delegation pattern:
  * - A single listener per event type is attached to `document.body` with
  *   `capture: true` (so it fires even for non-bubbling events).
  * - When an event fires, the handler walks up the DOM from `event.target`
- *   using `closest()` to find the nearest element with an `on-action`
- *   attribute whose event type matches.
+ *   using `closest()` to find the nearest element with an `on-<eventType>`
+ *   attribute (e.g. `on-click`, `on-submit`).
  * - Modifiers and payload resolvers run in the same pipeline as before.
  * - `dispatchAction` is called with the resolved payload.
  *
@@ -35,7 +35,7 @@
  * - `stop` stops further bubbling but the delegation handler has already
  *   captured the event at `body` level — it does not prevent other delegation
  *   handlers from running on the same element.
- * - `once` is emulated by delete attribute elements after first fire.
+ * - `once` is emulated by removing the attribute after first fire.
  */
 /**
  * Default DOM event types that cover the vast majority of interactive elements.
@@ -50,11 +50,11 @@
  */
 export declare const DEFAULT_DELEGATED_EVENTS: readonly string[];
 /**
- * Registers global event delegation for `on-action` attributes.
+ * Registers global event delegation for `on-<eventType>` attributes.
  *
  * Attaches a single `capture`-phase listener on `document.body` for each
- * event type in `eventTypes`. All `on-action` processing — modifier execution,
- * payload resolution, and `dispatchAction` — happens inside that one handler.
+ * event type in `eventTypes`. All processing — modifier execution, payload
+ * resolution, and `dispatchAction` — happens inside that one handler.
  *
  * **Call this once at application bootstrap**, before any user interaction.
  * Subsequent calls with the same event types are no-ops (idempotent).
@@ -80,7 +80,7 @@ export declare const DEFAULT_DELEGATED_EVENTS: readonly string[];
  * // One call activates the entire page.
  * setupActionDelegation();
  *
- * onAction('open-drawer', (panel) => openDrawer(panel));
+ * onAction('open_drawer', (panel) => openDrawer(panel));
  * ```
  *
  * @example — with extra event types

package/dist/delegate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../src/delegate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAoMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAA2C,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,GAAE,SAAS,MAAM,EAA6B,GAAG,IAAI,CASpG;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}
+{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../src/delegate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AA8LH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAA2C,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,GAAE,SAAS,MAAM,EAA6B,GAAG,IAAI,CASpG;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}

package/dist/main.d.ts

@@ -1,17 +1,29 @@
 /**
  * @alwatr/action — Declarative DOM action-dispatch for Unidirectional Data Flow.
  *
- * ## Activating `on-action` attributes
+ * ## Activating `on-<eventType>` attributes
  *
  * Call `setupActionDelegation()` once at bootstrap. A single capture-phase
- * listener on `document.body` handles every `on-action` element — including
- * elements added dynamically after bootstrap — with O(1) initialization cost.
+ * listener on `document.body` handles every `on-click`, `on-submit`, etc. element —
+ * including elements added dynamically after bootstrap — with O(1) initialization cost.
  *
  * ```ts
  * import {setupActionDelegation, onAction} from '@alwatr/action';
  *
  * setupActionDelegation();
- * onAction('open-drawer', (panel) => openDrawer(panel));
+ * onAction('open_drawer', (panel) => openDrawer(panel));
+ * ```
+ *
+ * ## Attribute syntax
+ *
+ * ```
+ * on-<eventType>="actionId[:payload][; modifier1,modifier2,…]"
+ * ```
+ *
+ * ```html
+ * <button on-click="open_drawer:main">Open</button>
+ * <input on-input="search_query:$value" />
+ * <form on-submit="submit_form:$formdata; prevent,validate" novalidate>…</form>
  * ```
  *
  * ## Programmatic dispatch
@@ -30,8 +42,8 @@
  * // src/action-record.ts
  * declare module '@alwatr/action' {
  *   interface ActionRecord {
- *     'open-drawer': string;
- *     'add-to-cart': {productId: number; qty: number};
+ *     'open_drawer': string;
+ *     'add_to_cart': {productId: number; qty: number};
  *     'logout': void;
  *   }
  * }

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,YAAY,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,YAAY,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}

package/dist/main.js

@@ -1,5 +1,5 @@
-/* 📦 @alwatr/action v9.14.0 */
-import{createLogger as U}from"@alwatr/logger";import{createChannelSignal as w}from"@alwatr/signal";var D=U("alwatr-action"),Z=w({name:"alwatr-action"});var N=new Map,Q=new Map;N.set("prevent",(q)=>{return q.preventDefault(),!0});N.set("validate",(q,z)=>{let G=z instanceof HTMLFormElement?z:z.closest("form");if(!G)return!1;return G.checkValidity()});Q.set("$value",(q,z)=>{return"value"in z?z.value:null});Q.set("$formdata",(q,z)=>{let G=z instanceof HTMLFormElement?z:z.closest("form");return G?Object.fromEntries(new FormData(G).entries()):null});function R(q,z){return D.logMethodArgs?.("onAction",{actionId:q}),Z.on(q,z)}function k(...q){let[z,G]=q;D.logMethodArgs?.("dispatchAction",{actionId:z,actionPayload:G}),Z.dispatch(z,G)}function E(q,z){if(D.logMethodArgs?.("registerModifier",{name:q}),N.has(q))D.accident("registerModifier","modifier_already_registered",{name:q});N.set(q,z)}function V(q,z){if(D.logMethodArgs?.("registerPayloadResolver",{name:q}),Q.has(q))D.accident("registerPayloadResolver","payload_resolver_already_registered",{name:q});Q.set(q,z)}var x=/^([a-z0-9.-]+)->([a-z0-9-]+)(?::(.+))?$/,X=new Map;function B(q){D.logMethodArgs?.("parseDescriptor__",{attributeValue:q});let z=X.get(q);if(z!==void 0)return z;let G=q.match(x);if(!G)return D.accident("parseDescriptor__","invalid_syntax",{attributeValue:q}),X.set(q,null),null;let[S,...F]=G[1].split(".");if(!S)return D.accident("parseDescriptor__","missing_event_type",{attributeValue:q}),X.set(q,null),null;let J=new Set(F),W=G[2],K=G[3],Y={eventType:S,modifiers:J,actionId:W,payload:K};return X.set(q,Y),Y}var M="on-action";function O(q){let z=q.type;D.logMethodArgs?.("handleDelegatedEvent__",{eventType:z});let G=q.target;if(!G)return;let S=G.closest?.(`[${M}^=${z}]`);if(!S)return;let F=S.getAttribute?.(M)?.trim();if(!F){D.accident("handleDelegatedEvent__","empty_attribute",{eventType:z,attributeValue:F,actionElement:S});return}if(!(S instanceof HTMLElement)){D.accident("handleDelegatedEvent__","target_not_html_element",{eventType:z,attributeValue:F,actionElement:S});return}let J=B(F);if(!J){D.accident("handleDelegatedEvent__","invalid_attribute",{eventType:z,attributeValue:F,actionElement:S});return}if(J.eventType!==z)return;if(D.logMethodArgs?.("handleDelegatedEvent__.action",J),J.modifiers.has("once"))S.removeAttribute(M),X.delete(F);for(let K of J.modifiers){if(K==="once")continue;let Y=N.get(K);if(!Y){D.accident("handleDelegatedEvent__","unknown_modifier",{modifier:K,attributeValue:F});return}if(Y(q,S)===!1)return}let W=J.payload;if(W){let K=Q.get(W);if(K)W=K(q,S)}Z.dispatch(J.actionId,W)}var H=new Set,P=["click","submit","input","change"];function y(q=P){D.logMethodArgs?.("setupActionDelegation",{eventTypes:q});for(let z of q){if(H.has(z))continue;H.add(z),document.body.addEventListener(z,O,{capture:!0})}}function p(){D.logMethod?.("teardownActionDelegation");for(let q of H)document.body.removeEventListener(q,O,{capture:!0});H.clear(),X.clear()}export{p as teardownActionDelegation,y as setupActionDelegation,V as registerPayloadResolver,E as registerModifier,R as onAction,k as dispatchAction,P as DEFAULT_DELEGATED_EVENTS};
+/* 📦 @alwatr/action v9.16.0 */
+import{createLogger as U}from"@alwatr/logger";import{createChannelSignal as W}from"@alwatr/signal";var F=U("alwatr-action"),Y=W({name:"alwatr-action"});var N=new Map,J=new Map;N.set("prevent",(D)=>{return D.preventDefault(),!0});N.set("validate",(D,q)=>{let z=q instanceof HTMLFormElement?q:q.closest("form");if(!z)return!1;return z.checkValidity()});J.set("$value",(D,q)=>{return"value"in q?q.value:null});J.set("$formdata",(D,q)=>{let z=q instanceof HTMLFormElement?q:q.closest("form");return z?Object.fromEntries(new FormData(z)):null});J.set("$checked",(D,q)=>{return"checked"in q?q.checked:null});function E(D,q){return F.logMethodArgs?.("onAction",{actionId:D}),Y.on(D,q)}function R(...D){let[q,z]=D;F.logMethodArgs?.("dispatchAction",{actionId:q,actionPayload:z}),Y.dispatch(q,z)}function V(D,q){if(F.logMethodArgs?.("registerModifier",{name:D}),N.has(D))F.accident("registerModifier","modifier_already_registered",{name:D});N.set(D,q)}function f(D,q){if(F.logMethodArgs?.("registerPayloadResolver",{name:D}),J.has(D))F.accident("registerPayloadResolver","payload_resolver_already_registered",{name:D});J.set(D,q)}var B=/^([a-z0-9_-]+)(?::([^;]+))?(?:;\s*([a-z0-9_,-]+))?$/,Z=new Map;function L(D){F.logMethodArgs?.("parseDescriptor__",{attributeValue:D});let q=Z.get(D);if(q!==void 0)return q;let z=D.match(B);if(!z)return F.accident("parseDescriptor__","invalid_syntax",{attributeValue:D}),Z.set(D,null),null;let X=z[1],G=z[2],O=z[3],K={modifiers:O?new Set(O.split(",").filter(Boolean)):new Set,actionId:X,payload:G};return Z.set(D,K),K}function M(D){let q=D.type;F.logMethodArgs?.("handleDelegatedEvent__",{eventType:q});let z=D.target;if(!z)return;let X=`on-${q}`,G=z.closest?.(`[${X}]`);if(!G)return;let O=G.getAttribute?.(X)?.trim();if(!O){F.accident("handleDelegatedEvent__","empty_attribute",{eventType:q,actionElement:G});return}if(!(G instanceof HTMLElement)){F.accident("handleDelegatedEvent__","target_not_html_element",{eventType:q,actionElement:G});return}let w=L(O);if(!w)return;if(F.logMethodArgs?.("handleDelegatedEvent__.action",{eventType:q,descriptor:w}),w.modifiers.has("once"))G.removeAttribute(X);for(let Q of w.modifiers){if(Q==="once")continue;let H=N.get(Q);if(!H){F.accident("handleDelegatedEvent__","unknown_modifier",{eventType:q,modifier:Q,attributeValue:O,descriptor:w});return}if(H(D,G)===!1)return}let K=w.payload;if(K){let Q=J.get(K);if(Q)K=Q(D,G)}Y.dispatch(w.actionId,K)}var A=new Set,S=["click","submit","input","change"];function _(D=S){F.logMethodArgs?.("setupActionDelegation",{eventTypes:D});for(let q of D){if(A.has(q))continue;A.add(q),document.body.addEventListener(q,M,{capture:!0})}}function u(){F.logMethod?.("teardownActionDelegation");for(let D of A)document.body.removeEventListener(D,M,{capture:!0});A.clear(),Z.clear()}export{u as teardownActionDelegation,_ as setupActionDelegation,f as registerPayloadResolver,V as registerModifier,E as onAction,R as dispatchAction,S as DEFAULT_DELEGATED_EVENTS};
 
-//# debugId=7E5E853AFB39285764756E2164756E21
+//# debugId=C5F4214484C292C364756E2164756E21
 //# sourceMappingURL=main.js.map