@a11d/lit 0.2.8 → 0.2.9

package/dist/Component/Component.d.ts

@@ -1,22 +1,22 @@
-import { LitElement, PropertyValues } from 'lit';
-export declare const component: (tagName: string) => (classOrDescriptor: {
-    prototype: HTMLElement;
-} | import("@lit/reactive-element/decorators/base.js").ClassDescriptor) => any;
-export declare abstract class Component extends LitElement {
-    /** Invoked after first update i.e. render is completed */
-    protected initialized(): void;
-    /** Invoked every time the component is connected to the Document Object Model (DOM) */
-    protected connected(): void;
-    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
-    protected disconnected(): void;
-    /** The template rendered into renderRoot. Invoked on each update to perform rendering tasks. */
-    protected get template(): import("lit-html").HTMLTemplateResult;
-    /** @final */
-    protected render(): import("lit-html").HTMLTemplateResult;
-    /** @final */
-    protected firstUpdated(props: PropertyValues): void;
-    /** @final */
-    connectedCallback(): void;
-    /** @final */
-    disconnectedCallback(): void;
-}
+import { LitElement, PropertyValues } from 'lit';
+export declare const component: (tagName: string) => (classOrDescriptor: {
+    prototype: HTMLElement;
+} | import("@lit/reactive-element/decorators/base.js").ClassDescriptor) => any;
+export declare abstract class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    protected initialized(): void;
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    protected connected(): void;
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    protected disconnected(): void;
+    /** The template rendered into renderRoot. Invoked on each update to perform rendering tasks. */
+    protected get template(): import("lit-html").HTMLTemplateResult;
+    /** @final */
+    protected render(): import("lit-html").HTMLTemplateResult;
+    /** @final */
+    protected firstUpdated(props: PropertyValues): void;
+    /** @final */
+    connectedCallback(): void;
+    /** @final */
+    disconnectedCallback(): void;
+}

package/dist/Component/Component.js

@@ -1,35 +1,35 @@
-import { LitElement } from 'lit';
-import { customElement } from 'lit/decorators.js';
-import { nothing } from './nothing.js';
-export const component = customElement;
-export class Component extends LitElement {
-    /** Invoked after first update i.e. render is completed */
-    initialized() { }
-    /** Invoked every time the component is connected to the Document Object Model (DOM) */
-    connected() { }
-    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
-    disconnected() { }
-    /** The template rendered into renderRoot. Invoked on each update to perform rendering tasks. */
-    get template() {
-        return nothing;
-    }
-    /** @final */
-    render() {
-        return this.template;
-    }
-    /** @final */
-    firstUpdated(props) {
-        super.firstUpdated(props);
-        this.initialized();
-    }
-    /** @final */
-    connectedCallback() {
-        super.connectedCallback();
-        this.connected();
-    }
-    /** @final */
-    disconnectedCallback() {
-        super.disconnectedCallback();
-        this.disconnected();
-    }
-}
+import { LitElement } from 'lit';
+import { customElement } from 'lit/decorators.js';
+import { nothing } from './nothing.js';
+export const component = customElement;
+export class Component extends LitElement {
+    /** Invoked after first update i.e. render is completed */
+    initialized() { }
+    /** Invoked every time the component is connected to the Document Object Model (DOM) */
+    connected() { }
+    /** Invoked every time the component is disconnected from the Document Object Model (DOM) */
+    disconnected() { }
+    /** The template rendered into renderRoot. Invoked on each update to perform rendering tasks. */
+    get template() {
+        return nothing;
+    }
+    /** @final */
+    render() {
+        return this.template;
+    }
+    /** @final */
+    firstUpdated(props) {
+        super.firstUpdated(props);
+        this.initialized();
+    }
+    /** @final */
+    connectedCallback() {
+        super.connectedCallback();
+        this.connected();
+    }
+    /** @final */
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.disconnected();
+    }
+}

package/dist/Component/index.d.ts

@@ -1,2 +1,2 @@
-export * from './nothing.js';
-export * from './Component.js';
+export * from './nothing.js';
+export * from './Component.js';

package/dist/Component/index.js

@@ -1,2 +1,2 @@
-export * from './nothing.js';
-export * from './Component.js';
+export * from './nothing.js';
+export * from './Component.js';

package/dist/Component/nothing.d.ts

@@ -1,2 +1,2 @@
-import { HTMLTemplateResult } from 'lit';
-export declare const nothing: HTMLTemplateResult;
+import { HTMLTemplateResult } from 'lit';
+export declare const nothing: HTMLTemplateResult;

package/dist/Component/nothing.js

@@ -1,2 +1,2 @@
-import { nothing as litNothing } from 'lit';
-export const nothing = litNothing;
+import { nothing as litNothing } from 'lit';
+export const nothing = litNothing;

package/dist/Controller/Controller.d.ts

@@ -1,9 +1,9 @@
-import { ReactiveController, ReactiveControllerHost } from 'lit';
-export declare abstract class Controller implements ReactiveController {
-    protected readonly host: ReactiveControllerHost;
-    constructor(host: ReactiveControllerHost);
-    hostConnected?(): void;
-    hostDisconnected?(): void;
-    hostUpdate?(): void;
-    hostUpdated?(): void;
-}
+import { ReactiveController, ReactiveControllerHost } from 'lit';
+export declare abstract class Controller implements ReactiveController {
+    protected readonly host: ReactiveControllerHost;
+    constructor(host: ReactiveControllerHost);
+    hostConnected?(): void;
+    hostDisconnected?(): void;
+    hostUpdate?(): void;
+    hostUpdated?(): void;
+}

package/dist/Controller/Controller.js

@@ -1,6 +1,6 @@
-export class Controller {
-    constructor(host) {
-        this.host = host;
-        this.host.addController(this);
-    }
-}
+export class Controller {
+    constructor(host) {
+        this.host = host;
+        this.host.addController(this);
+    }
+}

package/dist/Controller/index.d.ts

@@ -1 +1 @@
-export * from './Controller.js';
+export * from './Controller.js';

package/dist/Controller/index.js

@@ -1 +1 @@
-export * from './Controller.js';
+export * from './Controller.js';

package/dist/event/EventDispatcher.d.ts

@@ -1,9 +1,9 @@
-declare global {
-    export type EventHandler<T> = (data: T) => void;
-    export interface EventDispatcher<T = void> {
-        dispatch(value: T): void;
-        subscribe(handler: EventHandler<T>): void;
-        unsubscribe(handler: EventHandler<T>): void;
-    }
-}
-export {};
+declare global {
+    export type EventHandler<T> = (data: T) => void;
+    export interface EventDispatcher<T = void> {
+        dispatch(value: T): void;
+        subscribe(handler: EventHandler<T>): void;
+        unsubscribe(handler: EventHandler<T>): void;
+    }
+}
+export {};

package/dist/event/EventDispatcher.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/event/HTMLElementEventDispatcher.d.ts

@@ -1,12 +1,12 @@
-type CustomEventHandler<T> = (event: CustomEvent<T>) => void;
-export declare class HTMLElementEventDispatcher<T = void> implements EventDispatcher<T> {
-    protected readonly element: HTMLElement;
-    protected readonly type: string;
-    protected readonly options?: EventInit | undefined;
-    protected readonly handlersMap: Map<EventHandler<T>, CustomEventHandler<T>>;
-    constructor(element: HTMLElement, type: string, options?: EventInit | undefined);
-    dispatch(value: T | CustomEvent<T>): void;
-    subscribe(handler: EventHandler<T>): void;
-    unsubscribe(handler: EventHandler<T>): void;
-}
-export {};
+type CustomEventHandler<T> = (event: CustomEvent<T>) => void;
+export declare class HTMLElementEventDispatcher<T = void> implements EventDispatcher<T> {
+    protected readonly element: HTMLElement;
+    protected readonly type: string;
+    protected readonly options?: EventInit | undefined;
+    protected readonly handlersMap: Map<EventHandler<T>, CustomEventHandler<T>>;
+    constructor(element: HTMLElement, type: string, options?: EventInit | undefined);
+    dispatch(value: T | CustomEvent<T>): void;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+}
+export {};

package/dist/event/HTMLElementEventDispatcher.js

@@ -1,27 +1,27 @@
-export class HTMLElementEventDispatcher {
-    constructor(element, type, options) {
-        this.element = element;
-        this.type = type;
-        this.options = options;
-        this.handlersMap = new Map();
-    }
-    dispatch(value) {
-        this.element.dispatchEvent(value instanceof CustomEvent
-            ? value
-            : new CustomEvent(this.type, { detail: value, ...this.options }));
-    }
-    subscribe(handler) {
-        if (this.handlersMap.has(handler) === false) {
-            const nativeHandler = (event) => handler(event.detail);
-            this.element.addEventListener(this.type, nativeHandler);
-            this.handlersMap.set(handler, nativeHandler);
-        }
-    }
-    unsubscribe(handler) {
-        const nativeHandler = this.handlersMap.get(handler);
-        if (nativeHandler) {
-            this.element.removeEventListener(this.type, nativeHandler);
-        }
-        this.handlersMap.delete(handler);
-    }
-}
+export class HTMLElementEventDispatcher {
+    constructor(element, type, options) {
+        this.element = element;
+        this.type = type;
+        this.options = options;
+        this.handlersMap = new Map();
+    }
+    dispatch(value) {
+        this.element.dispatchEvent(value instanceof CustomEvent
+            ? value
+            : new CustomEvent(this.type, { detail: value, ...this.options }));
+    }
+    subscribe(handler) {
+        if (this.handlersMap.has(handler) === false) {
+            const nativeHandler = (event) => handler(event.detail);
+            this.element.addEventListener(this.type, nativeHandler);
+            this.handlersMap.set(handler, nativeHandler);
+        }
+    }
+    unsubscribe(handler) {
+        const nativeHandler = this.handlersMap.get(handler);
+        if (nativeHandler) {
+            this.element.removeEventListener(this.type, nativeHandler);
+        }
+        this.handlersMap.delete(handler);
+    }
+}

package/dist/event/PureEventDispatcher.d.ts

@@ -1,6 +1,6 @@
-export declare class PureEventDispatcher<T = void> implements EventDispatcher<T> {
-    private readonly handlers;
-    subscribe(handler: EventHandler<T>): void;
-    unsubscribe(handler: EventHandler<T>): void;
-    dispatch(data: T): void;
-}
+export declare class PureEventDispatcher<T = void> implements EventDispatcher<T> {
+    private readonly handlers;
+    subscribe(handler: EventHandler<T>): void;
+    unsubscribe(handler: EventHandler<T>): void;
+    dispatch(data: T): void;
+}

package/dist/event/PureEventDispatcher.js

@@ -1,16 +1,16 @@
-export class PureEventDispatcher {
-    constructor() {
-        this.handlers = new Set();
-    }
-    subscribe(handler) {
-        this.handlers.add(handler);
-    }
-    unsubscribe(handler) {
-        this.handlers.delete(handler);
-    }
-    dispatch(data) {
-        for (const handler of this.handlers) {
-            handler(data);
-        }
-    }
-}
+export class PureEventDispatcher {
+    constructor() {
+        this.handlers = new Set();
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+    }
+    unsubscribe(handler) {
+        this.handlers.delete(handler);
+    }
+    dispatch(data) {
+        for (const handler of this.handlers) {
+            handler(data);
+        }
+    }
+}

package/dist/event/event.d.ts

@@ -1 +1 @@
-export declare function event(options?: EventInit): (prototype: unknown, propertyKey?: string) => void;
+export declare function event(options?: EventInit): (prototype: unknown, propertyKey?: string) => void;

package/dist/event/event.js

@@ -1,20 +1,20 @@
-import { HTMLElementEventDispatcher } from './HTMLElementEventDispatcher.js';
-import { PureEventDispatcher } from './PureEventDispatcher.js';
-export function event(options) {
-    return (prototype, propertyKey) => {
-        if (propertyKey === undefined) {
-            return;
-        }
-        const eventFieldName = `$${propertyKey}Event$`;
-        Object.defineProperty(prototype, propertyKey, {
-            get() {
-                if (!this[eventFieldName]) {
-                    this[eventFieldName] = this instanceof HTMLElement
-                        ? new HTMLElementEventDispatcher(this, propertyKey, options)
-                        : new PureEventDispatcher();
-                }
-                return this[eventFieldName];
-            }
-        });
-    };
-}
+import { HTMLElementEventDispatcher } from './HTMLElementEventDispatcher.js';
+import { PureEventDispatcher } from './PureEventDispatcher.js';
+export function event(options) {
+    return (prototype, propertyKey) => {
+        if (propertyKey === undefined) {
+            return;
+        }
+        const eventFieldName = `$${propertyKey}Event$`;
+        Object.defineProperty(prototype, propertyKey, {
+            get() {
+                if (!this[eventFieldName]) {
+                    this[eventFieldName] = this instanceof HTMLElement
+                        ? new HTMLElementEventDispatcher(this, propertyKey, options)
+                        : new PureEventDispatcher();
+                }
+                return this[eventFieldName];
+            }
+        });
+    };
+}

package/dist/event/index.d.ts

@@ -1,4 +1,4 @@
-import './EventDispatcher.js';
-export * from './PureEventDispatcher.js';
-export * from './HTMLElementEventDispatcher.js';
-export * from './event.js';
+import './EventDispatcher.js';
+export * from './PureEventDispatcher.js';
+export * from './HTMLElementEventDispatcher.js';
+export * from './event.js';

package/dist/event/index.js

@@ -1,4 +1,4 @@
-import './EventDispatcher.js';
-export * from './PureEventDispatcher.js';
-export * from './HTMLElementEventDispatcher.js';
-export * from './event.js';
+import './EventDispatcher.js';
+export * from './PureEventDispatcher.js';
+export * from './HTMLElementEventDispatcher.js';
+export * from './event.js';

package/dist/eventListener/EventListenerController.d.ts

@@ -1,23 +1,23 @@
-import { ReactiveElement } from 'lit';
-import { Controller } from '../Controller/Controller.js';
-import type { EventListenerTarget } from './EventListenerTarget.js';
-export declare function extractEventTargets(this: any, target: EventListenerTarget | undefined): Promise<EventTarget[]>;
-type Listener = EventListenerObject | ((e: any) => void);
-type FullEventListenerControllerOptions = {
-    type: string;
-    listener: Listener;
-    target?: EventListenerTarget;
-    options?: EventListenerOptions | boolean;
-};
-type ShorthandEventListenerControllerOptions = [type: string, listener: Listener, options?: EventListenerOptions | boolean];
-type EventListenerControllerOptions = ShorthandEventListenerControllerOptions | [FullEventListenerControllerOptions];
-export declare class EventListenerController extends Controller {
-    protected readonly host: ReactiveElement;
-    protected readonly options: FullEventListenerControllerOptions;
-    constructor(host: ReactiveElement, ...options: EventListenerControllerOptions);
-    subscribe(): Promise<void>;
-    unsubscribe(): Promise<void>;
-    hostDisconnected(): Promise<void>;
-    hostConnected(): Promise<void>;
-}
-export {};
+import { ReactiveElement } from 'lit';
+import { Controller } from '../Controller/Controller.js';
+import type { EventListenerTarget } from './EventListenerTarget.js';
+export declare function extractEventTargets(this: any, target: EventListenerTarget | undefined): Promise<EventTarget[]>;
+type Listener = EventListenerObject | ((e: any) => void);
+type FullEventListenerControllerOptions = {
+    type: string;
+    listener: Listener;
+    target?: EventListenerTarget;
+    options?: EventListenerOptions | boolean;
+};
+type ShorthandEventListenerControllerOptions = [type: string, listener: Listener, options?: EventListenerOptions | boolean];
+type EventListenerControllerOptions = ShorthandEventListenerControllerOptions | [FullEventListenerControllerOptions];
+export declare class EventListenerController extends Controller {
+    protected readonly host: ReactiveElement;
+    protected readonly options: FullEventListenerControllerOptions;
+    constructor(host: ReactiveElement, ...options: EventListenerControllerOptions);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    hostDisconnected(): Promise<void>;
+    hostConnected(): Promise<void>;
+}
+export {};

package/dist/eventListener/EventListenerController.js

@@ -1,57 +1,57 @@
-import { Controller } from '../Controller/Controller.js';
-export async function extractEventTargets(target) {
-    const handle = (value) => {
-        return Symbol.iterator in value ? [...value] : [value];
-    };
-    if (target === undefined) {
-        return handle(this);
-    }
-    if (typeof target === 'function') {
-        let eventTarget = target.call(this);
-        if (eventTarget instanceof Promise) {
-            eventTarget = await eventTarget;
-        }
-        if (eventTarget instanceof EventTarget) {
-            return handle(eventTarget);
-        }
-        if (Symbol.iterator in eventTarget && [...eventTarget].every(t => t instanceof EventTarget)) {
-            return handle(eventTarget);
-        }
-        throw new TypeError(`${this.constructor}.target is not an EventTarget`);
-    }
-    return handle(target ?? this);
-}
-function extractOptions(options) {
-    const short = ((args) => typeof args[0] === 'string')(options);
-    return {
-        target: short ? undefined : options[0].target,
-        type: short ? options[0] : options[0].type,
-        listener: short ? options[1] : options[0].listener,
-        options: short ? options[2] : options[0].options,
-    };
-}
-export class EventListenerController extends Controller {
-    constructor(host, ...options) {
-        super(host);
-        this.host = host;
-        this.options = extractOptions(options);
-    }
-    async subscribe() {
-        const targets = await extractEventTargets.call(this.host, this.options.target);
-        for (const target of targets) {
-            target.removeEventListener(this.options.type, this.options.listener, this.options.options);
-        }
-    }
-    async unsubscribe() {
-        const targets = await extractEventTargets.call(this.host, this.options.target);
-        for (const target of targets) {
-            target?.addEventListener(this.options.type, this.options.listener, this.options.options);
-        }
-    }
-    async hostDisconnected() {
-        await this.subscribe();
-    }
-    async hostConnected() {
-        await this.unsubscribe();
-    }
-}
+import { Controller } from '../Controller/Controller.js';
+export async function extractEventTargets(target) {
+    const handle = (value) => {
+        return Symbol.iterator in value ? [...value] : [value];
+    };
+    if (target === undefined) {
+        return handle(this);
+    }
+    if (typeof target === 'function') {
+        let eventTarget = target.call(this);
+        if (eventTarget instanceof Promise) {
+            eventTarget = await eventTarget;
+        }
+        if (eventTarget instanceof EventTarget) {
+            return handle(eventTarget);
+        }
+        if (Symbol.iterator in eventTarget && [...eventTarget].every(t => t instanceof EventTarget)) {
+            return handle(eventTarget);
+        }
+        throw new TypeError(`${this.constructor}.target is not an EventTarget`);
+    }
+    return handle(target ?? this);
+}
+function extractOptions(options) {
+    const short = ((args) => typeof args[0] === 'string')(options);
+    return {
+        target: short ? undefined : options[0].target,
+        type: short ? options[0] : options[0].type,
+        listener: short ? options[1] : options[0].listener,
+        options: short ? options[2] : options[0].options,
+    };
+}
+export class EventListenerController extends Controller {
+    constructor(host, ...options) {
+        super(host);
+        this.host = host;
+        this.options = extractOptions(options);
+    }
+    async subscribe() {
+        const targets = await extractEventTargets.call(this.host, this.options.target);
+        for (const target of targets) {
+            target.removeEventListener(this.options.type, this.options.listener, this.options.options);
+        }
+    }
+    async unsubscribe() {
+        const targets = await extractEventTargets.call(this.host, this.options.target);
+        for (const target of targets) {
+            target?.addEventListener(this.options.type, this.options.listener, this.options.options);
+        }
+    }
+    async hostDisconnected() {
+        await this.subscribe();
+    }
+    async hostConnected() {
+        await this.unsubscribe();
+    }
+}

package/dist/eventListener/EventListenerTarget.d.ts

@@ -1,3 +1,3 @@
-type Targets = EventTarget | Iterable<EventTarget>;
-export type EventListenerTarget = Targets | ((this: any) => Targets | Promise<Targets>);
-export {};
+type Targets = EventTarget | Iterable<EventTarget>;
+export type EventListenerTarget = Targets | ((this: any) => Targets | Promise<Targets>);
+export {};

package/dist/eventListener/EventListenerTarget.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/eventListener/eventListener.d.ts

@@ -1,12 +1,12 @@
-import type { ReactiveElement } from 'lit';
-import type { EventListenerTarget } from './EventListenerTarget.js';
-type ShorthandEventListenerDecoratorOptions = [type: string, options?: EventListenerOptions | boolean];
-type FullEventListenerDecoratorOptions = {
-    type: string;
-    target?: EventListenerTarget;
-    options?: EventListenerOptions | boolean;
-};
-type EventListenerDecoratorOptions = ShorthandEventListenerDecoratorOptions | [FullEventListenerDecoratorOptions];
-export declare function extractOptions(args: EventListenerDecoratorOptions): FullEventListenerDecoratorOptions;
-export declare const eventListener: (...eventListenerOptions: EventListenerDecoratorOptions) => (prototype: ReactiveElement, propertyKey: string, descriptor?: PropertyDescriptor) => void;
-export {};
+import type { ReactiveElement } from 'lit';
+import type { EventListenerTarget } from './EventListenerTarget.js';
+type ShorthandEventListenerDecoratorOptions = [type: string, options?: EventListenerOptions | boolean];
+type FullEventListenerDecoratorOptions = {
+    type: string;
+    target?: EventListenerTarget;
+    options?: EventListenerOptions | boolean;
+};
+type EventListenerDecoratorOptions = ShorthandEventListenerDecoratorOptions | [FullEventListenerDecoratorOptions];
+export declare function extractOptions(args: EventListenerDecoratorOptions): FullEventListenerDecoratorOptions;
+export declare const eventListener: (...eventListenerOptions: EventListenerDecoratorOptions) => (prototype: ReactiveElement, propertyKey: string, descriptor?: PropertyDescriptor) => void;
+export {};