@twobirds/microcomponents 0.1.21 → 0.2.0

package/dist/core/MC.d.ts

@@ -0,0 +1,401 @@
+/**
+@module
+## Overview
+
+MicroComponents (MC) is a lightweight pattern for creating self-contained, event-driven, and composable UI components. It provides two core base classes: {@link MC} and {@link DC}, which differ primarily in their target attachment strategy and runtime environment requirements.
+
+In general, your code extends from either of these classes depending on whether you need DOM interaction or pure logic encapsulation.
+
+---
+
+## MC vs DC: Server vs Client
+
+The key distinction between the two base classes is their execution context:
+
+- **MC (MicroComponent)** – A general-purpose component that works in **any JavaScript environment**, including server-side runtimes (Node.js, Deno, etc.). It does not require a DOM and can be used for business logic, state management, or as a lightweight container. The `target` parameter is optional.
+
+- **DC (DOM Component)** – A DOM-centric component that operates wherever a real ( browser ) or simulated ( jsdom, etc. ) DOM exists. It attaches itself to an {@link HTMLElement} and provides event handling, DOM traversal, and lifecycle management. The `target` parameter is required and must be an HTMLElement.
+
+**HINT:** DCs can be attached to **any** DOM node ( HTMLElement ). That is you can connect them to <div>, <span> and the like. With a trick you can even define custom elements that convert themselves to e.g. a plain <div>.
+
+### When to use which?
+
+| Scenario | Recommended Class |
+|----------|-------------------|
+| Server-side rendering or logic | MC |
+| Pure data processing without DOM | MC |
+| Interactive UI elements in the browser | DC |
+| Event-driven components attached to HTML nodes | DC |
+
+---
+
+## The `target` Property: Backreference Concept
+
+Both MC and DC store a reference to their **host object** via the internal `_target` property (exposed as the `target` getter). This is a *backreference* — it points back to the object that contains or hosts this component instance.
+
+- For **DC instances**, `this.target` refers to the {@link HTMLElement} in the DOM (or testing DOM such as jsdom) to which the component is attached.
+- For **MC instances**, `this.target` can be any arbitrary object, allowing flexible composition patterns.
+
+The reference is held via a `WeakRef` ([MDN WeakRef](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef)) internally to avoid circular references and prevent memory leaks.
+
+---
+
+## DOM Integration: The `_mc` Property and `data-mc` Attribute
+
+When a DC is attached to an element via {@linkcode DC.add}, two things happen:
+
+1. The element gains a `_mc` property (of type {@link McHost}) that holds references to all attached microcomponents, keyed by their unique identifiers.
+2. The element receives a `data-mc` attribute, signaling that it hosts at least one microcomponent. This attribute is used internally for DOM queries and selectors.
+
+This `_mc` property is the **only** interference with the native DOM structure, ensuring compatibility with other frameworks or libraries.
+
+---
+
+## Lifecycle & Automatic Event Handler Attachment
+
+DC instances automatically trigger an `"Init"` lifecycle event asynchronously after construction. Additionally, methods prefixed with `on` or `one` (e.g., `onClick`, `oneUpdate`) are auto-attached as event listeners on the target element, supporting both native HTML events and custom microcomponent events.
+
+---
+
+
+@example Understanding target in DC
+
+javascript:
+```javascript
+import { DC } from '@twobirds/microcomponents';
+
+class MyButton extends DC {
+    constructor(target: HTMLElement) {
+        super(target);
+    }
+
+    logTarget() {
+        // this.target is the <button> element itself
+        console.log(this.target.tagName); // "BUTTON"
+    }
+}
+
+const btn = document.querySelector('button');
+if (btn) {
+    const host = DC.add(btn, 'myButton', new MyButton(btn));
+    host._mc.myButton.logTarget();
+}
+```
+
+@example Understanding target in MC
+
+
+```javascript
+import { MC } from '@twobirds/microcomponents';
+
+class Counter extends MC {
+    private count = 0;
+
+    constructor(target?: object) {
+        super(target);
+    }
+
+    increment() {
+        this.count++;
+    }
+
+    getCount() {
+        return this.count;
+    }
+}
+
+// Works without any DOM — usable on server or client
+const counter = new Counter();
+counter.increment();
+console.log(counter.getCount()); // 1
+```
+
+@example Usage
+
+Below is a complete example demonstrating how to create, attach, and interact with a custom microcomponent:
+
+html before:
+```html
+<div id="container"></div>
+```
+
+javascript:
+```javascript
+import { DC } from '@twobirds/microcomponents';
+
+// 1. Create a custom micro component class extending DC
+class HelloWorld extends DC {
+    constructor(target: HTMLElement) {
+        super(target);
+    }
+
+    greet() {
+        console.log('Hello World');
+    }
+}
+
+// 2. Get an element from the DOM
+const element = document.getElementById('container')!;
+
+// 3. Attach the micro component instance to the target element
+DC.add(element, 'helloWorld', new HelloWorld(element));
+
+// 4. Invoke methods on the attached component
+element._mc.helloWorld.greet(); // "Hello World"
+```
+
+html after:
+```html
+<div id="container" data-mc></div>
+```
+
+The `data-mc` attribute indicates that this element contains at least one microcomponent. The `_mc` property provides direct programmatic access to the attached instances.
+
+---
+
+*/
+import { BubbleController } from './events.js';
+import type { BubbleDirections, McController, McEntriesOf, McEventHandler, McHost, McHostOf, McMerged, McPayloadOf, McRemoved } from '../types/mcTypes.js';
+export type { McBubbleController, McController, McDetail, McEntriesOf, McEvent, McEventHandler, McHost, McHostOf, McMerged, McNativeEventHandlers, McPayloadOf, McRemoved, } from '../types/mcTypes.js';
+export { isMcDOM } from './mcGuards.js';
+/**
+The base class for all microcomponents.
+
+Implements a `WeakRef` to the target DOM element or other data, avoiding
+circular references. Automatically triggers the "Init" lifecycle event and
+attaches listeners via `autoAttachListeners` upon construction.
+*/
+declare class McBase<TTarget extends object = object> {
+    private _target;
+    /**
+    The constructor for the base `McBase` class.
+    
+    Initializes a weak reference to the target and triggers auto-attachment
+    of listeners and initialization lifecycle events.
+    
+    @param target - The object or element this microcomponent represents.
+    */
+    constructor(target: TTarget);
+    /**
+    Returns the current target object (DOM node or other data) referenced by this microcomponent.
+    
+    Uses a `WeakRef` internally to avoid circular references, and safely dereferences it here.
+    
+    The dereference is asserted non-null: the controller is stored on its target
+    (`element._mc`), so any code that can reach the controller through the element is
+    holding the target alive. Only a controller retained independently after its element
+    was garbage-collected could observe a stale reference — do not cache controllers
+    detached from their elements.
+
+    @returns The target object.
+    */
+    get target(): TTarget;
+}
+/**
+A general-purpose base microcomponent that does not require a DOM target.
+
+Inherits from `McBase`, but is primarily used as a lightweight container or
+for logic not directly tied to DOM elements.
+
+@template TTarget - The concrete type of the wrapped target data; preserved by
+    the `target` getter, so `new MC({ some: 'data' }).target.some` stays typed.
+*/
+declare class MC<TTarget extends object = object> extends McBase<TTarget> {
+    /**
+    Constructs an instance of the general-purpose microcomponent.
+    
+    @param target - Target object or data.
+    */
+    constructor(target: TTarget);
+}
+/**
+A DOM-centric microcomponent that operates on a specific HTML element.
+
+Extends `McBase` and associates itself with an actual DOM node via the
+`_target` reference. Provides methods for event handling, DOM traversal,
+and interaction with sibling or ancestor microcomponents.
+
+@template T - The concrete element type of the host element.
+@template EM - The component's custom event map (`event name → payload type`).
+    Declaring it registers events on the type level: `trigger()` enforces the
+    payload for registered names, and `on()`/`one()` handlers receive
+    `CustomEvent<McDetail<Payload>>` with no annotation needed. Unregistered
+    names keep the open `unknown`-payload behavior.
+@example
+```ts
+class Cart extends DC<HTMLFormElement, { CartUpdate: { count: number } }> {
+    checkout() {
+        this.trigger('CartUpdate', { count: 2 }, 'u'); // payload checked
+        this.on('CartUpdate', (ev) => ev.detail.data.count); // ev fully typed
+    }
+}
+```
+*/
+declare class DC<T extends HTMLElement = HTMLElement, EM extends Record<string, unknown> = Record<never, never>> extends McBase<T> implements McController<T> {
+    constructor(target: T);
+    /**
+    Static helper to attach a microcomponent instance to a DOM element.
+    
+    Wrapper around the `add()` utility function, providing a class-level API
+    for adding child microcomponents to a target node.
+    
+    @template T - The concrete element type of the target; preserved in the return type.
+    @template K - The literal registration key; becomes a known entry of the returned `_mc` registry.
+    @template E - The type of the attached element; retrievable as `result._mc[key]`.
+    @param target - The DOM element to which to attach the microcomponent.
+    @param key - The property name/key under which to store the instance in `_mc`.
+    @returns The target DOM element with the attached microcomponent.
+    */
+    static add<T extends HTMLElement>(target: T, key: string): McHost<McHostOf<T>, McEntriesOf<T>>;
+    /** @param element - The microcomponent instance or config object to attach. When
+        omitted, a bare `{}` marker is stored and no typed entry is claimed. */
+    static add<T extends HTMLElement, K extends string, E extends object>(target: T, key: K, element: E): McHost<McHostOf<T>, McMerged<McEntriesOf<T>, Record<K, E>>>;
+    /**
+    Static helper to remove a named microcomponent from a DOM element.
+
+    Wrapper around the `remove()` utility function, providing a class-level API
+    for removing child microcomponents.
+
+    @template T - A plain or already-enhanced element type.
+    @template K - The literal registration key; its entry is poisoned in the registry type.
+    @param target - The DOM element from which to remove the microcomponent.
+    @param key - The property name/key corresponding to the microcomponent to remove.
+    */
+    static remove<T extends HTMLElement, K extends string = string>(target: T, key: K): asserts target is T & McRemoved<T, K>;
+    /**
+    Class-verified entry lookup: returns the component stored under `key` on the
+    element's `_mc` record — but only if it is an instance of `Klass`.
+
+    This is the *sound* retrieval primitive: presence AND type identity are both
+    proven at runtime (`instanceof`), so it needs no global `McRegistry`
+    declaration and stays correct even when different elements use the same key
+    name for different component types. Accepts any value (including
+    `querySelector` results that may be null) — every failure mode returns
+    `undefined`.
+
+    @template E - The component type, inferred from `Klass`.
+    @param element - The value to look the entry up on; anything non-host yields undefined.
+    @param key - The registry key name to look under.
+    @param elementMcClass - The class the entry must be an instance of.
+    @returns The verified instance, or undefined.
+    @example
+    ```ts
+    const cart = DC.get(document.querySelector('form'), 'cart', Cart);
+    cart?.addItem(item); // Cart | undefined — no global declaration involved
+    ```
+    */
+    static get<E extends object>(element: unknown, key: string, elementMcClass: abstract new (...args: never[]) => E): E | undefined;
+    /**
+    Detaches an event listener from the DOM node.
+
+    This is an instance method wrapper for `off()`, using the internal `_target` DOM reference.
+
+    @param eventName - The name of the event (e.g., 'click', 'update').
+    @param handler - The previously attached callback function or object to remove.
+    */
+    off<D = unknown, K extends string = string>(eventName: K, handler: McEventHandler<McPayloadOf<EM, K, D>>): void;
+    off(eventName: string, handler: EventListenerOrEventListenerObject): void;
+    /**
+    Attaches a persistent event listener to the DOM node.
+    
+    This is an instance method wrapper for `on()`, using the internal `_target` DOM reference.
+    
+    The handler receives a `CustomEvent<McDetail<Payload>>`. For event names
+    registered in the component's event map `EM` the payload is resolved from the
+    map — an unannotated arrow handler is fully typed. For unregistered names the
+    payload defaults to `unknown` and can be pinned via the type argument
+    (`on<Payload>('Name', handler)`) or the handler's own annotation.
+    
+    @param eventName - The name of the event (e.g., 'click', 'update').
+    @param handler - The callback function or object to invoke.
+    @returns The attached handler reference, unchanged — usable directly with {@link off}.
+    */
+    on<D = unknown, K extends string = string>(eventName: K, handler: McEventHandler<McPayloadOf<EM, K, D>>): McEventHandler<McPayloadOf<EM, K, D>>;
+    on(eventName: string, handler: EventListenerOrEventListenerObject): EventListenerOrEventListenerObject;
+    /**
+    Attaches a one-time event listener to the DOM node.
+    
+    This is an instance method wrapper for `one()`, using the internal `_target` DOM reference.
+    Payload typing follows the same rules as {@link DC.on}.
+    
+    @param eventName - The name of the event (e.g., 'click', 'update').
+    @param handler - The callback function or object to invoke once.
+    @returns The attached one-time handler reference, unchanged — usable directly with {@link off}.
+    */
+    one<D = unknown, K extends string = string>(eventName: K, handler: McEventHandler<McPayloadOf<EM, K, D>>): McEventHandler<McPayloadOf<EM, K, D>>;
+    one(eventName: string, handler: EventListenerOrEventListenerObject): EventListenerOrEventListenerObject;
+    /**
+    Triggers a custom event on the DOM node and optionally bubbles it.
+    
+    This is an instance method wrapper for `trigger()`, using the internal `_target` DOM reference.
+    
+    For event names registered in the component's event map `EM` the payload type
+    is enforced; unregistered names accept any payload (typed via inference or an
+    explicit `trigger<Payload>(...)` argument).
+    
+    @param eventName - The name of the event (will be prefixed if needed).
+    @param data - Additional data payload attached to `event.detail.data`.
+    @param bubble - Bubbling direction ('l', 'u', 'd' or combinations).
+    @param controller - Optional controller for managing bubbling behavior.
+    */
+    trigger<D = unknown, K extends string = string>(eventName: K, data?: McPayloadOf<EM, K, D>, bubble?: BubbleDirections, controller?: BubbleController): void;
+    /**
+    Returns an array of all ancestor microcomponents up the DOM tree.
+
+    Traverses upward from this element's target, collecting the `_mc` instances
+    of ancestor elements marked with `data-mc`. The keyed form only collects
+    hosts whose registry carries `key`, typed from the global {@link McRegistry}
+    binding — non-optional, since presence is checked during the walk.
+
+    @template R - Known registry entries of the results; pass a record to assert
+        a site-specific shape: `ancestors<{ cart: Cart }>()`. Defaults to none.
+    @returns An array of ancestor microcomponent instances (empty if none found).
+    */
+    ancestors<R extends Record<string, unknown> = Record<never, never>>(): (McController & R)[];
+    /** @param key - Optional registry key each collected ancestor must carry. */
+    ancestors<K extends keyof McRegistry & string>(key: K): (McController & Pick<McRegistry, K>)[];
+    /**
+    Returns the closest ancestor microcomponent or null if none found.
+
+    This method is equivalent to calling `ancestors()[0]`, but more concise.
+    The keyed form walks up to the nearest host whose registry carries `key`,
+    typed from the global {@link McRegistry} binding — non-optional, since
+    presence is checked during the walk.
+
+    @template R - Known registry entries of the result; pass a record to assert
+        a site-specific shape: `closest<{ cart: Cart }>()?.cart.addItem(...)`.
+        Defaults to none.
+    @returns The nearest matching ancestor's `_mc`, or null if not found.
+    */
+    closest<R extends Record<string, unknown> = Record<never, never>>(): (McController & R) | null;
+    /** @param key - Optional registry key the ancestor must carry. */
+    closest<K extends keyof McRegistry & string>(key: K): (McController & Pick<McRegistry, K>) | null;
+    /**
+    Returns an array of direct child microcomponents.
+
+    Calls `getMcChildNodes()` internally to find immediate descendants only,
+    excluding nested grandchildren and deeper levels. The keyed form filters to
+    hosts whose registry carries `key`; see {@link DC.closest}.
+
+    @template R - Known registry entries of the results; see {@link DC.closest}.
+    @returns An array of child microcomponent instances (empty if none found).
+    */
+    children<R extends Record<string, unknown> = Record<never, never>>(): (McController & R)[];
+    /** @param key - Optional registry key each child must carry. */
+    children<K extends keyof McRegistry & string>(key: K): (McController & Pick<McRegistry, K>)[];
+    /**
+    Returns an array of all descendant microcomponents recursively.
+
+    Uses a `querySelectorAll` query to collect every nested element marked with
+    `data-mc`, returning their associated `_mc` instances. The keyed form
+    filters to hosts whose registry carries `key`; see {@link DC.closest}.
+
+    @template R - Known registry entries of the results; see {@link DC.closest}.
+    @returns An array of descendant microcomponent instances (empty if none found).
+    */
+    descendants<R extends Record<string, unknown> = Record<never, never>>(): (McController & R)[];
+    /** @param key - Optional registry key each descendant must carry. */
+    descendants<K extends keyof McRegistry & string>(key: K): (McController & Pick<McRegistry, K>)[];
+}
+export { MC, DC, McBase };
+//# sourceMappingURL=MC.d.ts.map

package/dist/core/MC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MC.d.ts","sourceRoot":"","sources":["../../src/core/MC.ts"],"names":[],"mappings":"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"}