@ecopages/radiant 0.1.8 → 0.3.0-alpha.0

package/dist/core/radiant-component-ssr.d.ts

@@ -0,0 +1,29 @@
+import type { JsxRenderable } from '@ecopages/jsx';
+import type { RenderToStringOptions } from '@ecopages/jsx/server';
+import type { SsrSerializableContextProvider } from '../context/context-provider';
+import type { ReactiveProperty } from './radiant-element';
+import type { ReactivePropDefinition } from './reactive-prop-metadata';
+import type { SsrSerializableHydrationBinding } from './ssr-hydration-binding';
+type RadiantComponentSsrHost = {
+    constructor: CustomElementConstructor;
+    getAuthoredHydrationScriptMarkup?: () => string | undefined;
+    getContextProviders: () => SsrSerializableContextProvider[];
+    getHydrationBindings: () => SsrSerializableHydrationBinding[];
+    getSlotProjectionScriptTag?: () => string | undefined;
+    renderToString: (options?: RenderToStringOptions) => string;
+    getReactiveProperties: () => ReactiveProperty[];
+    getReactivePropDefinitions: () => ReactivePropDefinition[];
+    getPropertyValue: (name: string) => unknown;
+    listAttributeNames: () => string[];
+    getAttributeValue: (name: string) => string | null;
+};
+export declare class RadiantComponentSsrService {
+    private readonly host;
+    constructor(host: RadiantComponentSsrHost);
+    renderHost(): JsxRenderable;
+    renderHostToString(options?: RenderToStringOptions, attributes?: Record<string, string>): string;
+    private renderHostContent;
+    getHostAttributes(): Record<string, string>;
+    private getTagName;
+}
+export {};

package/dist/core/radiant-component-ssr.js

@@ -0,0 +1,3 @@
+import{X as a}from"../chunk-9554n9t4.js";import"../chunk-73x7jpdd.js";import"../chunk-ms6a9zdt.js";import"../chunk-dx1wqc00.js";import"../chunk-4cc2syf5.js";import"../chunk-8xy18qmz.js";export{a as RadiantComponentSsrService};
+
+//# debugId=96387B8B5ABCCFB864756E2164756E21

package/dist/core/radiant-component-ssr.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "96387B8B5ABCCFB864756E2164756E21",
+  "names": []
+}

package/dist/core/radiant-component.d.ts

@@ -0,0 +1,106 @@
+import { type JsxRenderable } from '@ecopages/jsx';
+import { type RenderToStringOptions } from '@ecopages/jsx/server';
+import { RadiantElement } from './radiant-element';
+/**
+ * A structured JSX-first Radiant base class.
+ * @typeParam Bindings - Explicit internal bindable shape. Include only the
+ * prop/state keys that JSX bindings should accept.
+ *
+ * Treat this as the component's internal reactive/bindable surface, not as the
+ * default public custom-element attribute contract. When a component exposes a
+ * narrower external API than its internal state, declare a separate public
+ * props type for the JSX intrinsic element and keep internal-only state out of
+ * that contract.
+ *
+ * Reusing the same type for both is fine only when the public props and the
+ * bindable reactive members are intentionally the same surface.
+ *
+ * - `render()` describes the view.
+ * - `update()` commits the current view into the host.
+ * - first render happens automatically on connect.
+ * - plain `@prop`, `@state`, and `@signal` reads performed during `render()`
+ *   participate in tracked rerender invalidation.
+ * - `update()` and `requestUpdate()` remain available when a rerender should be
+ *   scheduled from imperative work outside those tracked reads.
+ */
+export declare class RadiantComponent<Bindings extends object = {}> extends RadiantElement<Bindings> {
+    private isRendering;
+    private isFirstConnectPending;
+    private isRenderScheduled;
+    private needsRender;
+    private projectedSlotContent;
+    private renderSignal?;
+    private readonly renderWatcher;
+    private slotProjectionObserver?;
+    private slotProjectionVersion;
+    private readonly ssr;
+    connectedCallback(): void;
+    /**
+     * Returns the current component view.
+     *
+     * The base implementation behaves like `<slot />`, so authored host children
+     * pass through unchanged when a subclass does not override `render()`.
+     */
+    render(): JsxRenderable;
+    /**
+     * Serializes the current component view into HTML.
+     */
+    renderToString(options?: RenderToStringOptions): string;
+    /**
+     * Returns the component host and current view as a JSX element.
+     */
+    renderHost(): JsxRenderable;
+    /**
+     * Serializes the component host and current view into HTML.
+     */
+    renderHostToString(options?: RenderToStringOptions): string;
+    /**
+     * Hydrates an SSR-rendered component view in place.
+     */
+    hydrate(): void;
+    /**
+     * Queues a component rerender and coalesces repeated requests into the same
+     * microtask.
+     *
+     * Use this when reactive state may change multiple times in the same turn and
+     * the current view should refresh once with the final values.
+     */
+    requestUpdate(): void;
+    /**
+     * Explicitly rerenders the component into its host.
+     */
+    update(): void;
+    disconnectedCallback(): void;
+    /**
+     * Returns the first projected element assigned to the default or named slot.
+     *
+     * Use this when component logic needs direct access to authored light-DOM
+     * content after projection.
+     *
+     * @param name Optional slot name. Omit for the default slot.
+     */
+    getSlotElement<T extends Element = Element>(name?: string): T | null;
+    /**
+     * Returns all projected elements assigned to the default or named slot.
+     *
+     * Text nodes are intentionally excluded so the result matches the element-
+     * oriented query semantics used by Radiant decorators.
+     *
+     * @param name Optional slot name. Omit for the default slot.
+     */
+    getSlotElements<T extends Element = Element>(name?: string): T[];
+    protected shouldAutoBindReactiveMembers(): boolean;
+    protected getHostSsrAttributes(): Record<string, string>;
+    private ensureSlotProjectionState;
+    private getHostChildNodeCount;
+    private getSlotProjectionScriptTag;
+    private getAuthoredHydrationScriptMarkup;
+    private handleSlotProjectionMutations;
+    private addProjectedSlotNode;
+    private removeProjectedSlotNode;
+    private observeSlotProjection;
+    private disconnectSlotProjectionObserver;
+    private disconnectRenderWatcher;
+    private resolveTrackedRenderOutput;
+    private resolveRenderOutput;
+}

package/dist/core/radiant-component.js

@@ -0,0 +1,3 @@
+import{G as a}from"../chunk-17earqbr.js";import"../chunk-84fc8cz9.js";import"../chunk-9ascmjk3.js";import"../chunk-9554n9t4.js";import"../chunk-9gjmqxp2.js";import"../chunk-8dexhy6c.js";import"../chunk-8tvt04cm.js";import"../chunk-73x7jpdd.js";import"../chunk-ms6a9zdt.js";import"../chunk-dx1wqc00.js";import"../chunk-4cc2syf5.js";import"../chunk-ksv01cey.js";import"../chunk-8n2dhx28.js";import"../chunk-8xy18qmz.js";export{a as RadiantComponent};
+
+//# debugId=591CEE5AF32145BA64756E2164756E21

package/dist/core/radiant-component.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "591CEE5AF32145BA64756E2164756E21",
+  "names": []
+}

package/dist/core/radiant-element.d.ts

@@ -1,5 +1,14 @@
+import type { EventEmitter } from '../tools';
+import { type JsxRenderable, type SubscribableJsxValue } from '@ecopages/jsx';
+import type { SsrSerializableContextProvider } from '../context/context-provider';
 import type { UnknownContext } from '../context/types';
-import type { AttributeTypeConstant, ReadAttributeValueReturnType, WriteAttributeValueReturnType } from '../utils';
+import type { SsrSerializableHydrationBinding } from './ssr-hydration-binding';
+import { type AttributeTypeConstant, type ReadAttributeValueReturnType, type WriteAttributeValueReturnType } from '../utils/attribute-utils';
+declare const RadiantElementBase: {
+    new (): HTMLElement;
+    prototype: HTMLElement;
+};
+type ReactiveDependencyReader = () => unknown;
 /**
  * Possible positions to insert a rendered template.
  */
@@ -11,91 +20,342 @@ export type RadiantElementEventListener = {
     selector: string;
     type: string;
     listener: EventListener;
-    id: string;
     options?: AddEventListenerOptions;
 };
 /**
  * Represents a property metadata object.
  */
-export interface PropertyConfig {
+export interface ReactiveProperty<T = unknown> {
     type: AttributeTypeConstant;
-    propertyName: string;
-    attributeKey: string;
+    value?: T;
+    initialValue?: T;
+    name: string;
+    attribute: string;
     converter: {
         fromAttribute: (value: string) => ReadAttributeValueReturnType;
         toAttribute: (value: any) => WriteAttributeValueReturnType;
     };
 }
+/**
+ * Represents the options for a reactive property.
+ */
+export type ReactivePropertyOptions<T> = {
+    type: AttributeTypeConstant;
+    reflect?: boolean;
+    attribute?: string;
+    defaultValue?: T;
+    /**
+     * Exposes a JSX binding companion for the reactive property.
+     *
+     * - `true` creates a `$propertyName` accessor.
+     * - a string creates a custom accessor with that name.
+     * - `undefined` defers to the host default.
+     *
+     * The generated accessor returns a subscribable JSX child value so JSX can
+     * patch only the affected child part when the property changes.
+     */
+    bind?: boolean | string;
+};
+export type ReactiveBindingOption = boolean | string;
+export type ReactiveFieldOptions = {
+    /**
+     * Exposes a JSX binding companion for the reactive field.
+     *
+     * - `true` creates a `$fieldName` accessor.
+     * - a string creates a custom accessor with that name.
+     * - `undefined` defers to the host default.
+     */
+    bind?: ReactiveBindingOption;
+};
+export type ReactiveField<T = unknown> = {
+    name: string;
+    value: T;
+    initialValue: T;
+};
+type StringPropertyKey<Value> = Extract<keyof Value, string>;
+/**
+ * Value type produced by a JSX binding for a selected reactive member.
+ *
+ * Bindings preserve the original property type when it is already renderable by
+ * the Ecopages JSX runtime. For non-renderable values, the binding falls back
+ * to the broader `JsxRenderable` contract consumed by the renderer.
+ */
+export type ReactiveBindingValue<Host extends object, Property extends StringPropertyKey<Host>> = Host[Property] extends JsxRenderable ? Host[Property] : JsxRenderable;
+/**
+ * Namespace of cached JSX bindings keyed by the explicit bindable shape.
+ *
+ * Radiant exposes this namespace twice on every host:
+ *
+ * - `host.bindings.key` for the explicit form
+ * - `host.$.key` for the short form
+ *
+ * Both aliases resolve through the same cached binding objects as
+ * `host.bind('key')`.
+ */
+export type ReactiveBindings<Bindings extends object> = {
+    readonly [Property in StringPropertyKey<Bindings>]: SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+};
 /**
  * Represents an interface for a Radiant element.
+ * @typeParam Bindings - Explicit internal bindable shape used to type `bind()` and `getReactiveBinding()`.
+ *
+ * This shape describes which reactive members are exposed through `bindings`,
+ * `$`, and `bind(...)`. It does not automatically define the public JSX
+ * attribute contract for the custom element.
  */
-export interface IRadiantElement {
+export interface IRadiantElement<Bindings extends object = {}> {
+    /**
+     * Namespace of cached JSX bindings keyed by the explicit bindable shape.
+     */
+    readonly bindings: ReactiveBindings<Bindings>;
+    /**
+     * Short alias for {@link bindings}.
+     */
+    readonly $: ReactiveBindings<Bindings>;
     /**
      * Called when a property of the element is updated.
      * @param changedProperty - The name of the changed property.
      * @param oldValue - The old value of the property.
      * @param newValue - The new value of the property.
      */
-    updated(changedProperty: string, oldValue: unknown, newValue: unknown): void;
+    notifyUpdate(changedProperty: string, oldValue: unknown, newValue: unknown): void;
     /**
      * Subscribes to a Radiant element event.
      * @param event - The event listener to subscribe to.
      */
     subscribeEvent(event: RadiantElementEventListener): void;
+    /**
+     * Registers a callback to be invoked when a reactive property or field changes.
+     *
+     * @returns A cleanup function that unregisters the callback.
+     */
+    registerUpdateCallback(property: string, update: (...rest: any[]) => any): () => void;
+    /**
+     * Returns a subscribable JSX child binding for a reactive property or field.
+     *
+     * Prefer `this.bindings.key` or `this.$.key` in JSX render code when you want
+     * property access syntax without string literals.
+     */
+    bind<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    /**
+     * Returns a subscribable JSX child binding for a reactive property or field.
+     *
+     * This is the primitive lookup used by `bind()`, `bindings.key`, and `$.key`.
+     */
+    getReactiveBinding<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    /**
+     * Defines a stable JSX binding companion accessor for a reactive member.
+     *
+     * Companion bindings create properties such as `$count` directly on the host.
+     * Prefer the `bindings` or `$` namespace for new code when you want typed,
+     * explicit access to the configured bindable shape.
+     */
+    defineReactiveBinding(property: string, bind?: ReactiveBindingOption): void;
     /**
      * Subscribes to multiple Radiant element events.
      * @param events - The array of event listeners to subscribe to.
      */
     subscribeEvents(events: RadiantElementEventListener[]): void;
     /**
-     * Unsubscribes from a Radiant element event.
-     * @param id - The ID of the event listener to unsubscribe from.
+     * It adds a callback to be executed when the Radiant element is disconnected from the DOM.
+     */
+    registerCleanupCallback(callback: () => void): void;
+    /**
+     * Registers a callback to run on each future host connection.
+     *
+     * The callback is only invoked from `connectedCallback()`. Registering it
+     * after the host is already connected does not invoke it immediately.
+     */
+    registerConnectedCallback(callback: () => void): void;
+    /**
+     * Registers a raw value reader for a reactive member so that tracked render
+     * dependencies can read the underlying value without triggering the public
+     * getter's dependency tracking.
      */
-    unsubscribeEvent(id: string): void;
+    registerReactiveDependencyReader(property: string, read: () => unknown): void;
     /**
-     * Removes all subscribed events from the Radiant element.
+     * Records a tracked read of a reactive member during a component render,
+     * allowing the signals runtime to re-render only the affected parts.
      */
-    removeAllSubscribedEvents(): void;
+    trackReactiveRead(property: string): void;
     /**
-     * Renders a template into the specified target element.
+     * Renders a trusted HTML template string into the specified target element.
+     *
+     * **Security:** The `template` string is written to the DOM via `innerHTML`
+     * or `insertAdjacentHTML` without built-in sanitization. Callers are
+     * responsible for ensuring the input is trusted. Supply a `sanitize`
+     * function to transform the template before insertion.
+     *
      * @param options - The rendering options.
      * @param options.target - The target element to render the template into.
      * @param options.template - The template string to render.
      * @param options.insert - The position to insert the rendered template. (optional)
+     * @param options.sanitize - An optional function that transforms the template string before insertion.
      */
     renderTemplate(options: {
         target: HTMLElement;
         template: string;
         insert?: RenderInsertPosition;
+        sanitize?: (html: string) => string;
     }): void;
     /**
      * Called when the Radiant element is connected to a context.
      * @param context - The connected context.
      */
     connectedContextCallback(context: UnknownContext): void;
+    /**
+     * Gets a reference to a child element by its data-ref attribute.
+     * @param ref - The data-ref attribute value of the element to get.
+     * @param all - Whether to get all elements with the specified data-ref attribute value.
+     * @returns The element with the specified data-ref attribute value, an array of elements or null if no element was found.
+     */
+    getRef<T extends Element = Element>(ref: string, all: true): T[];
+    getRef<T extends Element = Element>(ref: string, all?: false): T | null;
 }
 /**
  * A base class for creating custom elements with reactive properties and event subscriptions.
+ * @typeParam Bindings - Explicit internal bindable shape. Include only the
+ * prop/state keys that JSX bindings should accept.
+ *
+ * Prefer a separate public props type for custom-element JSX declarations when
+ * the external attribute contract differs from the component's internal
+ * reactive state. Reuse the same type only when the public props and bindable
+ * members are intentionally identical.
  * @extends HTMLElement
- * @implements IRadiantElement
+ * @implements IRadiantElement<Bindings>
  */
-export declare class RadiantElement extends HTMLElement implements IRadiantElement {
-    propertyConfigMap: Map<string, PropertyConfig>;
-    updatesRegistry: Map<string, Set<string>>;
+export declare class RadiantElement<Bindings extends object = {}> extends RadiantElementBase implements IRadiantElement<Bindings> {
+    readonly bindings: ReactiveBindings<Bindings>;
+    readonly $: ReactiveBindings<Bindings>;
+    /**
+     * A map of property metadata objects, it contains useful information about the properties configured via decorators.
+     */
+    private reactiveProperties;
+    /**
+     * A map of reactive fields, it contains the reactive fields configured via decorators.
+     */
+    private reactiveFields;
+    /**
+     * Stable dependency nodes used when plain reactive member reads participate
+     * in tracked component renders.
+     */
+    private reactiveDependencies;
+    /**
+     * Raw value readers for reactive members whose public getter should also
+     * register tracked render dependencies.
+     */
+    private reactiveDependencyReaders;
+    /**
+     * Stable subscribable JSX bindings keyed by reactive property name.
+     */
+    private reactiveBindings;
+    /**
+     * Registered context providers keyed by decorated property name.
+     */
+    private contextProviders;
+    /**
+     * Registered keyed hydration payload producers appended to SSR host output.
+     */
+    private hydrationBindings;
+    /**
+     * A map of property update callbacks. These callbacks are called when a property is updated.
+     */
+    private updateCallbacks;
+    /**
+     * A map of event subscriptions used to manage event listeners on the Radiant element.
+     */
     private eventSubscriptions;
+    /**
+     * A map for event emitters
+     */
+    private eventEmitters;
+    /**
+     * Callbacks executed whenever the Radiant element is connected to the DOM.
+     */
+    private onConnectedCallbacks;
+    /**
+     * An array of cleanup callbacks to be executed when the Radiant element is disconnected from the DOM.
+     */
+    private onDisconnectedCallback;
+    /**
+     * A flag indicating whether the element has been connected to the DOM.
+     */
     private elementReady;
+    constructor();
+    private createReactiveBindingNamespace;
     connectedCallback(): void;
     connectedContextCallback(_contextName: UnknownContext): void;
     disconnectedCallback(): void;
-    updated(changedProperty: string, oldValue: unknown, value: unknown): void;
+    notifyUpdate(changedProperty: string, oldValue: unknown, value: unknown): void;
+    private transformAttributeValue;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    renderTemplate({ target, template, insert, }: {
+    /**
+     * Renders a trusted HTML template string into the specified target element.
+     *
+     * **Security:** The `template` string is written to the DOM via `innerHTML`
+     * or `insertAdjacentHTML` without built-in sanitization. Callers are
+     * responsible for ensuring the input is trusted. Supply a `sanitize`
+     * function to transform the template before insertion.
+     */
+    renderTemplate({ target, template, insert, sanitize, }: {
         target: HTMLElement;
         template: string;
         insert?: RenderInsertPosition;
+        sanitize?: (html: string) => string;
     }): void;
-    subscribeEvents(events: RadiantElementEventListener[]): void;
-    subscribeEvent(eventConfig: RadiantElementEventListener): void;
-    unsubscribeEvent(id: string): void;
-    removeAllSubscribedEvents(): void;
+    registerReactiveProperty(config: ReactiveProperty): void;
+    protected getReactiveProperties(): ReactiveProperty[];
+    registerReactiveField<T>(config: ReactiveField<T>): void;
+    registerReactiveDependencyReader(property: string, read: ReactiveDependencyReader): void;
+    registerContextProvider(name: string, provider: SsrSerializableContextProvider): void;
+    registerHydrationBinding(name: string, binding: SsrSerializableHydrationBinding): void;
+    protected getContextProviders(): SsrSerializableContextProvider[];
+    protected getHydrationBindings(): SsrSerializableHydrationBinding[];
+    /**
+     * Flushes any deferred SSR-only preparation work before the host is
+     * serialized.
+     *
+     * Radiant uses this to reapply SSR consumer state after construction so the
+     * first server render sees finalized fields, props, and authored content.
+     */
+    protected prepareForSsr(): void;
+    /**
+     * Returns the default JSX binding policy for reactive members on this host.
+     *
+     * Plain `RadiantElement` instances keep binding opt-in. JSX-first hosts such
+     * as `RadiantComponent` override this hook to opt into automatic bindings for
+     * `@prop`, `@state`, and direct `createReactiveProp`/`createReactiveField`
+     * calls when no explicit `bind` option is supplied.
+     */
+    protected shouldAutoBindReactiveMembers(): boolean;
+    registerUpdateCallback(property: string, update: (...rest: any[]) => any): () => void;
+    getReactiveBinding<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    bind<Property extends StringPropertyKey<Bindings>>(property: Property): SubscribableJsxValue<ReactiveBindingValue<Bindings, Property>>;
+    defineReactiveBinding(property: string, bind?: ReactiveBindingOption): void;
+    private getReactiveDependency;
+    trackReactiveRead(property: string): void;
+    private readReactiveDependencyValue;
+    private readReactiveBindingValue;
+    subscribeEvents(events: RadiantElementEventListener[]): Array<() => void>;
+    subscribeEvent(eventConfig: RadiantElementEventListener): () => void;
+    private unsubscribeEvent;
+    private removeAllSubscribedEvents;
+    /**
+     * Registers a callback that runs on every future disconnect.
+     */
+    registerCleanupCallback(callback: () => void): void;
+    /**
+     * Registers a callback that runs from `connectedCallback()` on future host
+     * connections.
+     *
+     * Registering after the host is already connected does not invoke the
+     * callback immediately.
+     */
+    registerConnectedCallback(callback: () => void): void;
+    registerEventEmitter(name: string, emitter: EventEmitter): void;
+    getRef<T extends Element = Element>(ref: string, all: true): T[];
+    getRef<T extends Element = Element>(ref: string, all?: false): T | null;
+    createReactiveField<T>(propertyName: string, initialValue: T, options?: ReactiveFieldOptions): void;
+    createReactiveProp<T = unknown>(propertyName: string, options: ReactivePropertyOptions<T>): void;
 }
+export {};

package/dist/core/radiant-element.js

@@ -1,83 +1,3 @@
-// src/core/radiant-element.ts
-class RadiantElement extends HTMLElement {
-  eventSubscriptions = new Map;
-  elementReady = false;
-  connectedCallback() {
-    this.elementReady = true;
-  }
-  connectedContextCallback(_contextName) {
-  }
-  disconnectedCallback() {
-    this.removeAllSubscribedEvents();
-  }
-  updated(changedProperty, oldValue, value) {
-    if (!this.elementReady || !this.updatesRegistry || oldValue === value)
-      return;
-    const updates = this.updatesRegistry.get(changedProperty);
-    if (updates) {
-      for (const update of updates) {
-        this[update]();
-      }
-    }
-  }
-  attributeChangedCallback(name, oldValue, newValue) {
-    if (oldValue === newValue || !this.elementReady)
-      return;
-    if (name in this) {
-      const config = this.propertyConfigMap.get(name);
-      const transformedValue = newValue ? config?.converter.fromAttribute(newValue) : newValue;
-      const transformedOldValue = oldValue ? config?.converter.fromAttribute(oldValue) : oldValue;
-      this[name] = transformedValue;
-      this.updated(name, transformedOldValue, transformedValue);
-    }
-  }
-  renderTemplate({
-    target = this,
-    template,
-    insert = "replace"
-  }) {
-    switch (insert) {
-      case "replace":
-        target.innerHTML = template;
-        break;
-      case "beforeend":
-        target.insertAdjacentHTML("beforeend", template);
-        break;
-      case "afterbegin":
-        target.insertAdjacentHTML("afterbegin", template);
-        break;
-    }
-  }
-  subscribeEvents(events) {
-    for (const event of events) {
-      this.subscribeEvent(event);
-    }
-  }
-  subscribeEvent(eventConfig) {
-    const delegatedListener = (delegatedEvent) => {
-      if (delegatedEvent.target && delegatedEvent.target.matches(eventConfig.selector)) {
-        eventConfig.listener.call(this, delegatedEvent);
-      }
-    };
-    this.addEventListener(eventConfig.type, delegatedListener, eventConfig.options);
-    this.eventSubscriptions.set(eventConfig.id, { ...eventConfig, listener: delegatedListener });
-  }
-  unsubscribeEvent(id) {
-    const eventSubscription = this.eventSubscriptions.get(id);
-    if (eventSubscription) {
-      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);
-      this.eventSubscriptions.delete(id);
-    }
-  }
-  removeAllSubscribedEvents() {
-    for (const eventSubscription of this.eventSubscriptions.values()) {
-      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);
-    }
-    this.eventSubscriptions.clear();
-  }
-}
-export {
-  RadiantElement
-};
+import{H as a}from"../chunk-84fc8cz9.js";import"../chunk-9gjmqxp2.js";import"../chunk-8tvt04cm.js";import"../chunk-73x7jpdd.js";import"../chunk-8xy18qmz.js";export{a as RadiantElement};
 
-//# debugId=494A682B938300F764756E2164756E21
+//# debugId=81AC4D5FEB0D36DD64756E2164756E21

package/dist/core/radiant-element.js.map

@@ -1,10 +1,9 @@
 {
   "version": 3,
-  "sources": ["../src/core/radiant-element.ts"],
+  "sources": [],
   "sourcesContent": [
-    "import type { UnknownContext } from '@/context/types';\nimport type { AttributeTypeConstant, ReadAttributeValueReturnType, WriteAttributeValueReturnType } from '@/utils';\n\n/**\n * Possible positions to insert a rendered template.\n */\nexport type RenderInsertPosition = 'replace' | 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';\n\n/**\n * Represents a Radiant element event listener.\n */\nexport type RadiantElementEventListener = {\n  selector: string;\n  type: string;\n  listener: EventListener;\n  id: string;\n  options?: AddEventListenerOptions;\n};\n\n/**\n * Represents a property metadata object.\n */\nexport interface PropertyConfig {\n  type: AttributeTypeConstant;\n  propertyName: string;\n  attributeKey: string;\n  converter: {\n    fromAttribute: (value: string) => ReadAttributeValueReturnType;\n    toAttribute: (value: any) => WriteAttributeValueReturnType;\n  };\n}\n\n/**\n * Represents an interface for a Radiant element.\n */\nexport interface IRadiantElement {\n  /**\n   * Called when a property of the element is updated.\n   * @param changedProperty - The name of the changed property.\n   * @param oldValue - The old value of the property.\n   * @param newValue - The new value of the property.\n   */\n  updated(changedProperty: string, oldValue: unknown, newValue: unknown): void;\n\n  /**\n   * Subscribes to a Radiant element event.\n   * @param event - The event listener to subscribe to.\n   */\n  subscribeEvent(event: RadiantElementEventListener): void;\n\n  /**\n   * Subscribes to multiple Radiant element events.\n   * @param events - The array of event listeners to subscribe to.\n   */\n  subscribeEvents(events: RadiantElementEventListener[]): void;\n\n  /**\n   * Unsubscribes from a Radiant element event.\n   * @param id - The ID of the event listener to unsubscribe from.\n   */\n  unsubscribeEvent(id: string): void;\n\n  /**\n   * Removes all subscribed events from the Radiant element.\n   */\n  removeAllSubscribedEvents(): void;\n\n  /**\n   * Renders a template into the specified target element.\n   * @param options - The rendering options.\n   * @param options.target - The target element to render the template into.\n   * @param options.template - The template string to render.\n   * @param options.insert - The position to insert the rendered template. (optional)\n   */\n  renderTemplate(options: {\n    target: HTMLElement;\n    template: string;\n    insert?: RenderInsertPosition;\n  }): void;\n\n  /**\n   * Called when the Radiant element is connected to a context.\n   * @param context - The connected context.\n   */\n  connectedContextCallback(context: UnknownContext): void;\n}\n\n/**\n * A base class for creating custom elements with reactive properties and event subscriptions.\n * @extends HTMLElement\n * @implements IRadiantElement\n */\nexport class RadiantElement extends HTMLElement implements IRadiantElement {\n  declare propertyConfigMap: Map<string, PropertyConfig>;\n  declare updatesRegistry: Map<string, Set<string>>;\n  private eventSubscriptions = new Map<string, RadiantElementEventListener>();\n  private elementReady = false;\n\n  connectedCallback() {\n    this.elementReady = true;\n  }\n\n  connectedContextCallback(_contextName: UnknownContext): void {}\n\n  disconnectedCallback() {\n    this.removeAllSubscribedEvents();\n  }\n\n  updated(changedProperty: string, oldValue: unknown, value: unknown) {\n    if (!this.elementReady || !this.updatesRegistry || oldValue === value) return;\n    const updates = this.updatesRegistry.get(changedProperty);\n    if (updates) {\n      for (const update of updates) {\n        (this as any)[update]();\n      }\n    }\n  }\n\n  attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null) {\n    if (oldValue === newValue || !this.elementReady) return;\n\n    if (name in this) {\n      const config = this.propertyConfigMap.get(name);\n      const transformedValue = newValue ? config?.converter.fromAttribute(newValue) : newValue;\n      const transformedOldValue = oldValue ? config?.converter.fromAttribute(oldValue) : oldValue;\n      (this as RadiantElement & { [key: string]: any })[name] = transformedValue;\n      this.updated(name, transformedOldValue, transformedValue);\n    }\n  }\n\n  renderTemplate({\n    target = this,\n    template,\n    insert = 'replace',\n  }: {\n    target: HTMLElement;\n    template: string;\n    insert?: RenderInsertPosition;\n  }) {\n    switch (insert) {\n      case 'replace':\n        target.innerHTML = template;\n        break;\n      case 'beforeend':\n        target.insertAdjacentHTML('beforeend', template);\n        break;\n      case 'afterbegin':\n        target.insertAdjacentHTML('afterbegin', template);\n        break;\n    }\n  }\n\n  public subscribeEvents(events: RadiantElementEventListener[]): void {\n    for (const event of events) {\n      this.subscribeEvent(event);\n    }\n  }\n\n  public subscribeEvent(eventConfig: RadiantElementEventListener): void {\n    const delegatedListener = (delegatedEvent: Event) => {\n      if (delegatedEvent.target && (delegatedEvent.target as Element).matches(eventConfig.selector)) {\n        eventConfig.listener.call(this, delegatedEvent);\n      }\n    };\n\n    this.addEventListener(eventConfig.type, delegatedListener, eventConfig.options);\n    this.eventSubscriptions.set(eventConfig.id, { ...eventConfig, listener: delegatedListener });\n  }\n\n  public unsubscribeEvent(id: string): void {\n    const eventSubscription = this.eventSubscriptions.get(id);\n    if (eventSubscription) {\n      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);\n      this.eventSubscriptions.delete(id);\n    }\n  }\n\n  public removeAllSubscribedEvents(): void {\n    for (const eventSubscription of this.eventSubscriptions.values()) {\n      this.removeEventListener(eventSubscription.type, eventSubscription.listener, eventSubscription.options);\n    }\n    this.eventSubscriptions.clear();\n  }\n}\n"
   ],
-  "mappings": ";AA4FO,MAAM,uBAAuB,YAAuC;AAAA,EAGjE,qBAAqB,IAAI;AAAA,EACzB,eAAe;AAAA,EAEvB,iBAAiB,GAAG;AAClB,SAAK,eAAe;AAAA;AAAA,EAGtB,wBAAwB,CAAC,cAAoC;AAAA;AAAA,EAE7D,oBAAoB,GAAG;AACrB,SAAK,0BAA0B;AAAA;AAAA,EAGjC,OAAO,CAAC,iBAAyB,UAAmB,OAAgB;AAClE,SAAK,KAAK,iBAAiB,KAAK,mBAAmB,aAAa;AAAO;AACvE,UAAM,UAAU,KAAK,gBAAgB,IAAI,eAAe;AACxD,QAAI,SAAS;AACX,iBAAW,UAAU,SAAS;AAC5B,QAAC,KAAa,QAAQ;AAAA,MACxB;AAAA,IACF;AAAA;AAAA,EAGF,wBAAwB,CAAC,MAAc,UAAyB,UAAyB;AACvF,QAAI,aAAa,aAAa,KAAK;AAAc;AAEjD,QAAI,QAAQ,MAAM;AAChB,YAAM,SAAS,KAAK,kBAAkB,IAAI,IAAI;AAC9C,YAAM,mBAAmB,WAAW,QAAQ,UAAU,cAAc,QAAQ,IAAI;AAChF,YAAM,sBAAsB,WAAW,QAAQ,UAAU,cAAc,QAAQ,IAAI;AACnF,MAAC,KAAiD,QAAQ;AAC1D,WAAK,QAAQ,MAAM,qBAAqB,gBAAgB;AAAA,IAC1D;AAAA;AAAA,EAGF,cAAc;AAAA,IACZ,SAAS;AAAA,IACT;AAAA,IACA,SAAS;AAAA,KAKR;AACD,YAAQ;AAAA,WACD;AACH,eAAO,YAAY;AACnB;AAAA,WACG;AACH,eAAO,mBAAmB,aAAa,QAAQ;AAC/C;AAAA,WACG;AACH,eAAO,mBAAmB,cAAc,QAAQ;AAChD;AAAA;AAAA;AAAA,EAIC,eAAe,CAAC,QAA6C;AAClE,eAAW,SAAS,QAAQ;AAC1B,WAAK,eAAe,KAAK;AAAA,IAC3B;AAAA;AAAA,EAGK,cAAc,CAAC,aAAgD;AACpE,UAAM,oBAAoB,CAAC,mBAA0B;AACnD,UAAI,eAAe,UAAW,eAAe,OAAmB,QAAQ,YAAY,QAAQ,GAAG;AAC7F,oBAAY,SAAS,KAAK,MAAM,cAAc;AAAA,MAChD;AAAA;AAGF,SAAK,iBAAiB,YAAY,MAAM,mBAAmB,YAAY,OAAO;AAC9E,SAAK,mBAAmB,IAAI,YAAY,IAAI,KAAK,aAAa,UAAU,kBAAkB,CAAC;AAAA;AAAA,EAGtF,gBAAgB,CAAC,IAAkB;AACxC,UAAM,oBAAoB,KAAK,mBAAmB,IAAI,EAAE;AACxD,QAAI,mBAAmB;AACrB,WAAK,oBAAoB,kBAAkB,MAAM,kBAAkB,UAAU,kBAAkB,OAAO;AACtG,WAAK,mBAAmB,OAAO,EAAE;AAAA,IACnC;AAAA;AAAA,EAGK,yBAAyB,GAAS;AACvC,eAAW,qBAAqB,KAAK,mBAAmB,OAAO,GAAG;AAChE,WAAK,oBAAoB,kBAAkB,MAAM,kBAAkB,UAAU,kBAAkB,OAAO;AAAA,IACxG;AACA,SAAK,mBAAmB,MAAM;AAAA;AAElC;",
-  "debugId": "494A682B938300F764756E2164756E21",
+  "mappings": "",
+  "debugId": "81AC4D5FEB0D36DD64756E2164756E21",
   "names": []
 }