element-vir/dist/declarative-element/properties/element-events.js

Heroic. Reactive. Declarative. Type safe. Web components without compromise.

import { defineTypedEvent, } from '../../typed-event/typed-event.js';
/**
 * Used to define element events, with a type.
 *
 * @category Element Definition
 * @example
 *
 * ```ts
 * import {html, defineElement, defineElementEvent, listen} from 'element-vir';
 *
 * const MyElement = defineElement()({
 *     tagName: 'my-element',
 *     events: {
 *         myOutput: defineElementEvent<number>(),
 *     },
 *     render({events, dispatch}) {
 *         return html`
 *             <div
 *                 ${listen('click', () => {
 *                     dispatch(new events.myOutput(1));
 *                 })}
 *             >
 *                 Some div
 *             </div>
 *         `;
 *     },
 * });
 * ```
 */
export function defineElementEvent() {
    return defineTypedEvent();
}
/**
 * Maps an element definition initialization's tag name and event map to a map of ready-to-construct
 * event classes. This also verifies that the input event init map has valid keys.
 *
 * @category Internal
 */
export function createEventDescriptorMap(tagName, eventsInit) {
    if (!eventsInit) {
        return {};
    }
    return (Object.keys(eventsInit)
        /** Verify event keys. */
        .filter((currentElementEventKey) => {
        if (typeof currentElementEventKey !== 'string') {
            throw new TypeError(`Expected event key of type string but got type '${typeof currentElementEventKey}' for key ${String(currentElementEventKey)}`);
        }
        else if (currentElementEventKey === '') {
            throw new Error('Got empty string for events key.');
        }
        return true;
    })
        .reduce((accum, currentElementEventKey) => {
        const eventObject = defineTypedEvent()([
            tagName,
            currentElementEventKey,
        ].join('-'));
        accum[currentElementEventKey] = eventObject;
        return accum;
    }, {}));
}