element-vir 6.3.3 → 7.0.0

package/dist/declarative-element/directives/assign.directive.js

@@ -1,28 +0,0 @@
-import { noChange } from 'lit';
-import { directive, Directive } from 'lit/directive.js';
-import { extractDeclarativeElement } from './directive-helpers';
-/** Assign an object matching an element's inputs to its inputs. */
-export function assign(declarativeElement, inputsObject) {
-    /**
-     * The directive generics (in listenDirective) are not strong enough to maintain their values.
-     * Thus, the directive call is wrapped in this function.
-     */
-    return assignDirective(declarativeElement, inputsObject);
-}
-const assignDirective = directive(class extends Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        this.element = extractDeclarativeElement(partInfo, 'assign');
-    }
-    render(elementDefinition, inputsObject) {
-        assignInputsObject(elementDefinition, this.element, inputsObject);
-        return noChange;
-    }
-});
-export function assignInputsObject(expectedElementConstructor, element, assignmentObject) {
-    if (element.tagName.toLowerCase() !== expectedElementConstructor.tagName.toLowerCase()) {
-        console.error(element, expectedElementConstructor);
-        throw new Error(`Assignment mismatch. Assignment was made for ${element.tagName.toLowerCase()} but it's attached to ${expectedElementConstructor.tagName.toLowerCase()}`);
-    }
-    element.assignInputs(assignmentObject);
-}

package/dist/declarative-element/directives/awaiting.directive.d.ts

@@ -1,18 +0,0 @@
-export type MaybePromise<T> = (T extends Promise<infer ValueType> ? T | ValueType : Promise<T> | T) | undefined | {
-    error: Error;
-};
-export type CreateStateUpdatingPromiseInputs<InnerValueGeneric, KeyGeneric extends PropertyKey, StateGeneric extends Readonly<Record<KeyGeneric, MaybePromise<InnerValueGeneric>>>> = {
-    updateState: (newState: Partial<StateGeneric>) => void;
-    stateKey: KeyGeneric;
-} & ({
-    createPromiseCallback: () => Promise<InnerValueGeneric>;
-    promise?: undefined;
-} | {
-    promise: Promise<InnerValueGeneric>;
-    createPromiseCallback?: undefined;
-});
-export declare function createStateUpdatingPromiseIfUndefined<InnerValueGeneric, KeyGeneric extends PropertyKey, StateGeneric extends Readonly<Record<KeyGeneric, MaybePromise<InnerValueGeneric>>>>(inputs: CreateStateUpdatingPromiseInputs<InnerValueGeneric, KeyGeneric, StateGeneric> & {
-    state: StateGeneric;
-}): void;
-export declare function awaiting<ValueGeneric, FallbackGeneric, CallbackReturnGeneric>(input: MaybePromise<ValueGeneric>, notResolvedYetFallback: FallbackGeneric, resolvedCallback: (resolved: ValueGeneric) => CallbackReturnGeneric): CallbackReturnGeneric | FallbackGeneric | Error | undefined;
-export declare function ensureError(input: unknown): Error;

package/dist/declarative-element/directives/awaiting.directive.js

@@ -1,42 +0,0 @@
-import { extractErrorMessage, isPromiseLike, typedHasProperty } from '@augment-vir/common';
-export function createStateUpdatingPromiseIfUndefined(inputs) {
-    const { state, stateKey } = inputs;
-    const currentValue = state[stateKey];
-    if (currentValue === undefined) {
-        createStateUpdatingPromise(inputs);
-    }
-}
-function createStateUpdatingPromise({ updateState, stateKey, createPromiseCallback: promiseCallback, promise, }) {
-    const output = promise !== null && promise !== void 0 ? promise : promiseCallback();
-    // as casts below are required because, even though all the generics agree, TypeScript can't figure that out here
-    if (output instanceof Promise) {
-        output
-            .then((result) => {
-            updateState({ [stateKey]: result });
-        })
-            .catch((thrownError) => {
-            const guaranteedError = ensureError(thrownError);
-            updateState({ [stateKey]: { error: guaranteedError } });
-        });
-    }
-    updateState({ [stateKey]: output });
-}
-export function awaiting(input, notResolvedYetFallback, resolvedCallback) {
-    if (isPromiseLike(input) || input == undefined) {
-        return notResolvedYetFallback;
-    }
-    else if (typedHasProperty(input, 'error')) {
-        return input.error;
-    }
-    else {
-        return resolvedCallback(input);
-    }
-}
-export function ensureError(input) {
-    if (input instanceof Error) {
-        return input;
-    }
-    else {
-        return new Error(extractErrorMessage(input));
-    }
-}

package/dist/declarative-element/directives/directive-helpers.d.ts

@@ -1,14 +0,0 @@
-import { ElementPartInfo, PartInfo } from 'lit/directive.js';
-import { DeclarativeElement } from '../declarative-element';
-/** For some reason these aren't defined in lit's types already. */
-export type ExtraPartInfoProperties = {
-    element: Element;
-    options: {
-        host: Element;
-        renderBefore: Element;
-        isConnected: boolean;
-    };
-};
-export declare function extractDeclarativeElement(partInfo: PartInfo, directiveName: string): DeclarativeElement;
-export declare function extractElement<ElementType = HTMLElement>(partInfo: PartInfo, directiveName: string, constructorClass: (new () => ElementType) | (abstract new () => ElementType)): ElementType;
-export declare function assertsIsElementPartInfo(partInfo: PartInfo, directiveName: string): asserts partInfo is ElementPartInfo & ExtraPartInfoProperties;

package/dist/declarative-element/directives/directive-helpers.js

@@ -1,21 +0,0 @@
-import { PartType } from 'lit/directive.js';
-import { DeclarativeElement } from '../declarative-element';
-export function extractDeclarativeElement(partInfo, directiveName) {
-    return extractElement(partInfo, directiveName, DeclarativeElement);
-}
-export function extractElement(partInfo, directiveName, constructorClass) {
-    assertsIsElementPartInfo(partInfo, directiveName);
-    const element = partInfo.element;
-    if (!(element instanceof constructorClass)) {
-        throw new Error(`${directiveName} attached to non ${constructorClass.name} element.`);
-    }
-    return element;
-}
-export function assertsIsElementPartInfo(partInfo, directiveName) {
-    if (partInfo.type !== PartType.ELEMENT) {
-        throw new Error(`${directiveName} directive can only be attached directly to an element.`);
-    }
-    if (!partInfo.element) {
-        throw new Error(`${directiveName} directive found no element.`);
-    }
-}

package/dist/declarative-element/directives/listen.directive.d.ts

@@ -1,14 +0,0 @@
-import { DirectiveResult } from 'lit/directive.js';
-import { DefinedTypedEvent, TypedEvent } from '../../typed-event/typed-event';
-/**
- * Listen to events. These can be native DOM events (use a string for the inputType argument) or
- * typed events (pass in a return value from defineTypedEvent).
- *
- * @param definedTypedEvent Needs to come either from a declarative element (like
- *   MyDeclarativeElement.events.eventName) or from a typed event created via the defineTypedEvent
- *   function.
- * @param listener The callback to fire when an event is caught. Assuming the definedTypedEvent
- *   input is properly typed, the event given to this callback will also be typed.
- */
-export declare function listen<TypedEventTypeNameGeneric extends string, TypedEventDetailGeneric, NativeElementEventNameGeneric extends keyof HTMLElementEventMap>(eventType: DefinedTypedEvent<TypedEventTypeNameGeneric, TypedEventDetailGeneric>, listener: (event: TypedEvent<TypedEventTypeNameGeneric, TypedEventDetailGeneric>) => void): DirectiveResult<any>;
-export declare function listen<TypedEventTypeNameGeneric extends string, TypedEventDetailGeneric, NativeElementEventNameGeneric extends keyof HTMLElementEventMap>(eventType: NativeElementEventNameGeneric, listener: (event: HTMLElementEventMap[NativeElementEventNameGeneric]) => void): DirectiveResult<any>;

package/dist/declarative-element/directives/listen.directive.js

@@ -1,47 +0,0 @@
-import { noChange } from 'lit';
-import { directive, Directive } from 'lit/directive.js';
-import { extractElement } from './directive-helpers';
-export function listen(eventType, listener) {
-    return listenDirective(eventType, listener);
-}
-/**
- * The directive generics here are not strong enough to maintain their values. Thus, the directive
- * call is wrapped in the function above.
- */
-const listenDirective = directive(class extends Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        this.element = extractElement(partInfo, 'listen', HTMLElement);
-    }
-    resetListener(listenerMetaData) {
-        if (this.lastListenerMetaData) {
-            this.element.removeEventListener(this.lastListenerMetaData.eventType, this.lastListenerMetaData.listener);
-        }
-        this.element.addEventListener(listenerMetaData.eventType, listenerMetaData.listener);
-        this.lastListenerMetaData = listenerMetaData;
-    }
-    createListenerMetaData(eventType, callback) {
-        return {
-            eventType,
-            callback,
-            listener: (event) => { var _a; return (_a = this.lastListenerMetaData) === null || _a === void 0 ? void 0 : _a.callback(event); },
-        };
-    }
-    render(eventTypeInput, callback) {
-        const eventType = typeof eventTypeInput === 'string' ? eventTypeInput : eventTypeInput.type;
-        if (typeof eventType !== 'string') {
-            throw new Error(`Cannot listen to an event with a name that is not a string. Given event name: "${eventType}"`);
-        }
-        if (this.lastListenerMetaData && this.lastListenerMetaData.eventType === eventType) {
-            /**
-             * Store the callback here so we don't have to update the attached listener every
-             * time the callback is updated.
-             */
-            this.lastListenerMetaData.callback = callback;
-        }
-        else {
-            this.resetListener(this.createListenerMetaData(eventType, callback));
-        }
-        return noChange;
-    }
-});

package/dist/declarative-element/directives/on-dom-created.directive.d.ts

@@ -1,11 +0,0 @@
-import { PartInfo } from 'lit/directive.js';
-export type OnDomCreatedCallback = (element: Element) => void;
-/** Only fires once, when the element has been created. */
-export declare const onDomCreated: (callback: OnDomCreatedCallback) => import("lit-html/directive").DirectiveResult<{
-    new (partInfo: PartInfo): {
-        element: Element | undefined;
-        update(partInfo: PartInfo, [callback]: [OnDomCreatedCallback]): undefined;
-        render(callback: OnDomCreatedCallback): undefined;
-        readonly _$isConnected: boolean;
-    };
-}>;

package/dist/declarative-element/directives/on-dom-created.directive.js

@@ -1,23 +0,0 @@
-import { directive, Directive } from 'lit/directive.js';
-import { assertsIsElementPartInfo } from './directive-helpers';
-const directiveName = 'onDomCreated';
-/** Only fires once, when the element has been created. */
-export const onDomCreated = directive(class extends Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        assertsIsElementPartInfo(partInfo, directiveName);
-    }
-    update(partInfo, [callback]) {
-        assertsIsElementPartInfo(partInfo, directiveName);
-        const newElement = partInfo.element;
-        if (newElement !== this.element) {
-            // use requestAnimationFrame here so it can fire property changes outside of a render loop
-            requestAnimationFrame(() => callback(newElement));
-            this.element = newElement;
-        }
-        return this.render(callback);
-    }
-    render(callback) {
-        return undefined;
-    }
-});

package/dist/declarative-element/directives/on-resize.directive.d.ts

@@ -1,15 +0,0 @@
-import { PartInfo } from 'lit/directive.js';
-export type OnResizeCallback = (
-/** Only these two properties are supported in all major modern browsers */
-entry: Readonly<Pick<ResizeObserverEntry, 'target' | 'contentRect'>>) => void;
-export declare const onResize: (callback: OnResizeCallback) => import("lit-html/directive").DirectiveResult<{
-    new (partInfo: PartInfo): {
-        element: Element | undefined;
-        readonly resizeObserver: ResizeObserver;
-        callback: OnResizeCallback | undefined;
-        fireCallback(entries: ResizeObserverEntry[]): void;
-        update(partInfo: PartInfo, [callback]: [OnResizeCallback]): undefined;
-        render(callback: OnResizeCallback): undefined;
-        readonly _$isConnected: boolean;
-    };
-}>;

package/dist/declarative-element/directives/on-resize.directive.js

@@ -1,36 +0,0 @@
-import { directive, Directive } from 'lit/directive.js';
-import { assertsIsElementPartInfo } from './directive-helpers';
-const directiveName = 'onResize';
-export const onResize = directive(class extends Directive {
-    constructor(partInfo) {
-        super(partInfo);
-        this.resizeObserver = new ResizeObserver((entries) => this.fireCallback(entries));
-        assertsIsElementPartInfo(partInfo, directiveName);
-    }
-    fireCallback(entries) {
-        var _a;
-        const resizeEntry = entries[0];
-        if (!resizeEntry) {
-            console.error(entries);
-            throw new Error(`${directiveName} observation triggered but the first entry was empty.`);
-        }
-        (_a = this.callback) === null || _a === void 0 ? void 0 : _a.call(this, { target: resizeEntry.target, contentRect: resizeEntry.contentRect });
-    }
-    update(partInfo, [callback]) {
-        assertsIsElementPartInfo(partInfo, directiveName);
-        this.callback = callback;
-        const newElement = partInfo.element;
-        // if the element changes we need to observe the new one
-        if (newElement !== this.element) {
-            if (this.element) {
-                this.resizeObserver.unobserve(this.element);
-            }
-            this.resizeObserver.observe(newElement);
-            this.element = newElement;
-        }
-        return this.render(callback);
-    }
-    render(callback) {
-        return undefined;
-    }
-});

package/dist/declarative-element/element-events.d.ts

@@ -1,10 +0,0 @@
-import { DefinedTypedEvent, DefinedTypedEventNameDefinition, TypedEvent } from '../typed-event/typed-event';
-export type EventsInitMap = Record<string, DefinedTypedEventNameDefinition<any>>;
-export declare function defineElementEvent<EventDetailGeneric>(): DefinedTypedEventNameDefinition<EventDetailGeneric>;
-export type EventInitMapEventDetailExtractor<EventTypeNameGeneric extends keyof EventsInitGeneric, EventsInitGeneric extends EventsInitMap> = EventsInitGeneric[EventTypeNameGeneric] extends DefinedTypedEventNameDefinition<infer R> ? R : never;
-export type EventDescriptorMap<EventsInitGeneric extends EventsInitMap> = {
-    [CurrentEventTypeName in keyof EventsInitGeneric]: DefinedTypedEvent<CurrentEventTypeName extends string ? CurrentEventTypeName : never, EventInitMapEventDetailExtractor<CurrentEventTypeName, EventsInitGeneric>>;
-};
-export type EventObjectEventDetailExtractor<EventObjectGeneric extends DefinedTypedEvent<any, any>> = EventObjectGeneric extends DefinedTypedEvent<string, infer R> ? R : never;
-export type ElementEventDetailExtractor<ElementEventGeneric extends TypedEvent<any, any>> = ElementEventGeneric extends TypedEvent<string, infer R> ? R : never;
-export declare function createEventDescriptorMap<EventsInitGeneric extends EventsInitMap>(eventsInit: EventsInitGeneric | undefined): EventDescriptorMap<EventsInitGeneric>;

package/dist/declarative-element/element-events.js

@@ -1,24 +0,0 @@
-import { defineTypedEvent, } from '../typed-event/typed-event';
-export function defineElementEvent() {
-    return defineTypedEvent();
-}
-export function createEventDescriptorMap(eventsInit) {
-    if (!eventsInit) {
-        return {};
-    }
-    return Object.keys(eventsInit)
-        .filter((currentElementEventKey) => {
-        if (typeof currentElementEventKey !== 'string') {
-            throw new Error(`Expected event key of type string but got type "${typeof currentElementEventKey}" for key ${String(currentElementEventKey)}`);
-        }
-        if (currentElementEventKey === '') {
-            throw new Error(`Got empty string for events key.`);
-        }
-        return true;
-    })
-        .reduce((accum, currentElementEventKey) => {
-        const eventObject = defineTypedEvent()(currentElementEventKey);
-        accum[currentElementEventKey] = eventObject;
-        return accum;
-    }, {});
-}

package/dist/declarative-element/element-properties.d.ts

@@ -1,16 +0,0 @@
-import { DeclarativeElement } from './declarative-element';
-export type PropertyInitMapBase = Record<PropertyKey, unknown>;
-export type ElementProperty<KeyGeneric extends string | number | symbol, ValueGeneric> = {
-    name: KeyGeneric;
-    setProp(value: ValueGeneric): void;
-    getProp(): ValueGeneric;
-};
-export type StaticElementPropertyDescriptor<PropName extends string, PropValue> = {
-    propName: PropName;
-    initValue: PropValue;
-};
-export type ElementPropertyDescriptorMap<PropertyInitGeneric extends PropertyInitMapBase> = {
-    [Property in keyof PropertyInitGeneric]: StaticElementPropertyDescriptor<string, PropertyInitGeneric[Property]>;
-};
-export declare function createElementUpdaterProxy<PropertyInitGeneric extends PropertyInitMapBase>(element: DeclarativeElement, verifyExists: boolean): PropertyInitGeneric;
-export declare function createPropertyDescriptorMap<PropertyInitGeneric extends PropertyInitMapBase>(propertyInit: PropertyInitGeneric | undefined): ElementPropertyDescriptorMap<PropertyInitGeneric>;

package/dist/declarative-element/element-properties.js

@@ -1,72 +0,0 @@
-function assertValidPropertyName(propKey, element, elementTagName) {
-    if (typeof propKey !== 'string' && typeof propKey !== 'number' && typeof propKey !== 'symbol') {
-        throw new Error(`Property name must be a string, got type "${typeof propKey}" from: "${String(propKey)}" for ${elementTagName.toLowerCase()}`);
-    }
-    if (!(propKey in element)) {
-        throw new Error(`Property "${String(propKey)}" does not exist on ${elementTagName.toLowerCase()}.`);
-    }
-}
-export function createElementUpdaterProxy(element, verifyExists) {
-    /**
-     * Lit element updates state and inputs by setting them directly on the element, so we must do
-     * that here. DeclarativeElement's types, however, do not expose this behavior, so we add that
-     * back in here.
-     */
-    const elementAsProps = element;
-    const propsProxy = new Proxy({}, {
-        get: (target, propertyName) => {
-            if (verifyExists) {
-                assertValidPropertyName(propertyName, element, element.tagName);
-            }
-            const targetValue = target[propertyName];
-            if (typeof targetValue === 'function') {
-                return targetValue.bind(target);
-            }
-            return elementAsProps[propertyName];
-        },
-        set: (target, propertyName, value) => {
-            if (verifyExists) {
-                assertValidPropertyName(propertyName, element, element.tagName);
-            }
-            target[propertyName] = value;
-            elementAsProps[propertyName] = value;
-            return true;
-        },
-        ownKeys: (target) => Reflect.ownKeys(target),
-        getOwnPropertyDescriptor(target, propertyName) {
-            if (propertyName in target) {
-                return {
-                    get value() {
-                        return target[propertyName];
-                    },
-                    configurable: true,
-                    enumerable: true,
-                };
-            }
-            return undefined;
-        },
-        has: (target, propertyName) => Reflect.has(target, propertyName),
-    });
-    return propsProxy;
-}
-export function createPropertyDescriptorMap(propertyInit) {
-    if (!propertyInit) {
-        return {};
-    }
-    return Object.keys(propertyInit)
-        .filter((key) => {
-        if (typeof key === 'string') {
-            return true;
-        }
-        else {
-            throw new Error(`Property init cannot have non string keys: "${key}"`);
-        }
-    })
-        .reduce((accum, currentKey) => {
-        accum[currentKey] = {
-            propName: currentKey,
-            initValue: propertyInit[currentKey],
-        };
-        return accum;
-    }, {});
-}

package/dist/declarative-element/has-declarative-element-parent.d.ts

@@ -1 +0,0 @@
-export declare function hasDeclarativeElementParent(input: Element): boolean;

package/dist/declarative-element/has-declarative-element-parent.js

@@ -1,16 +0,0 @@
-import { DeclarativeElement } from './declarative-element';
-export function hasDeclarativeElementParent(input) {
-    const rootNode = input.getRootNode();
-    if (!(rootNode instanceof ShadowRoot)) {
-        // declarative elements all use shadow DOM, so if a shadow root doesn't exist then we're not
-        // in a declarative element.
-        return false;
-    }
-    const host = rootNode.host;
-    if (host instanceof DeclarativeElement) {
-        return true;
-    }
-    else {
-        return hasDeclarativeElementParent(host);
-    }
-}

package/dist/declarative-element/host-classes.d.ts

@@ -1,21 +0,0 @@
-import { PropertyInitMapBase } from './element-properties';
-import { WithTagName } from './tag-name';
-export type HostClassToggleCallbackInput<InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase> = {
-    state: Readonly<StateGeneric>;
-    inputs: Readonly<InputsGeneric>;
-};
-export type HostClassToggleCallback<InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase> = (inputs: HostClassToggleCallbackInput<InputsGeneric, StateGeneric>) => boolean;
-export type HostClassesInitMap<HostClassKeys extends string, InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase> = Record<HostClassKeys, 
-/**
- * Callback to determine when host class should be enabled (based on current inputs and state),
- * or just undefined to mark that this host class name will only be manually applied.
- */
-HostClassToggleCallback<InputsGeneric, StateGeneric> | false>;
-export type HostClassName<TagName extends string, HostClassPropName extends string> = `${TagName}-${HostClassPropName}`;
-export type HostClassNamesMap<TagName extends string, HostClassKeys extends string> = Record<HostClassKeys, WithTagName<TagName, string>>;
-export declare function createHostClassNamesMap<TagName extends string, HostClassKeys extends string, HostClassesInitGeneric extends HostClassesInitMap<HostClassKeys, 
-/**
- * We can use any here because we don't care what the state or input names are, we just care
- * what the host class names are
- */
-any, any>>(tagName: TagName, hostClassesInit?: HostClassesInitGeneric): HostClassNamesMap<TagName, HostClassKeys>;

package/dist/declarative-element/host-classes.js

@@ -1,12 +0,0 @@
-import { mapObjectValues } from '@augment-vir/common';
-import { toHtmlSafeWithTagName } from './tag-name';
-export function createHostClassNamesMap(tagName, hostClassesInit) {
-    if (hostClassesInit) {
-        return mapObjectValues(hostClassesInit, (key) => {
-            return toHtmlSafeWithTagName(tagName, String(key));
-        });
-    }
-    else {
-        return {};
-    }
-}

package/dist/declarative-element/render-callback.d.ts

@@ -1,22 +0,0 @@
-import { TemplateResult } from 'lit';
-import { TypedEvent } from '../typed-event/typed-event';
-import { DeclarativeElement, HostInstanceType } from './declarative-element';
-import { EventDescriptorMap, EventInitMapEventDetailExtractor, EventsInitMap } from './element-events';
-import { PropertyInitMapBase } from './element-properties';
-export type RenderCallback<InputsGeneric extends PropertyInitMapBase = any, StateGeneric extends PropertyInitMapBase = any, EventsInitGeneric extends EventsInitMap = any, HostClassKeys extends string = any, CssVarKeys extends string = any> = (params: RenderParams<InputsGeneric, StateGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys>) => TemplateResult;
-export type InitCallback<InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase, EventsInitGeneric extends EventsInitMap, HostClassKeys extends string, CssVarKeys extends string> = (params: RenderParams<InputsGeneric, StateGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys>) => void;
-export type UpdateStateCallback<StateGeneric extends PropertyInitMapBase> = (newState: Partial<StateGeneric>) => void;
-export type RenderParams<InputsGeneric extends PropertyInitMapBase, StateInitGeneric extends PropertyInitMapBase, EventsInitGeneric extends EventsInitMap, HostClassKeys extends string, CssVarKeys extends string> = {
-    state: Readonly<StateInitGeneric>;
-    updateState: UpdateStateCallback<StateInitGeneric>;
-    events: EventDescriptorMap<EventsInitGeneric>;
-    host: HostInstanceType<InputsGeneric, StateInitGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys>;
-    dispatch: <EventTypeNameGeneric extends keyof EventsInitGeneric>(event: TypedEvent<EventTypeNameGeneric extends string ? EventTypeNameGeneric : never, EventInitMapEventDetailExtractor<EventTypeNameGeneric, EventsInitGeneric>>) => boolean;
-    inputs: InputsGeneric;
-    /**
-     * Same as dispatchElementEvent but without the extra types. This allows you to emit any events,
-     * even events from other custom elements.
-     */
-    genericDispatch: (event: Event) => boolean;
-};
-export declare function createRenderParams<InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase, EventsInitGeneric extends EventsInitMap, HostClassKeys extends string, CssVarKeys extends string>(element: DeclarativeElement<InputsGeneric, StateGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys>, eventsMap: EventDescriptorMap<EventsInitGeneric>): RenderParams<InputsGeneric, StateGeneric, EventsInitGeneric, HostClassKeys, CssVarKeys>;

package/dist/declarative-element/render-callback.js

@@ -1,21 +0,0 @@
-import { getObjectTypedKeys } from '@augment-vir/common';
-export function createRenderParams(element, eventsMap) {
-    const renderParams = {
-        /**
-         * These two dispatch properties do the same thing but their interfaces are different.
-         * DispatchEvent's type interface is much stricter.
-         */
-        dispatch: (event) => element.dispatchEvent(event),
-        genericDispatch: (event) => element.dispatchEvent(event),
-        updateState: (partialProps) => {
-            getObjectTypedKeys(partialProps).forEach((propKey) => {
-                element.instanceState[propKey] = partialProps[propKey];
-            });
-        },
-        inputs: element.instanceInputs,
-        host: element,
-        state: element.instanceState,
-        events: eventsMap,
-    };
-    return renderParams;
-}

package/dist/declarative-element/styles.d.ts

@@ -1,23 +0,0 @@
-import { CSSResult } from 'lit';
-import { CssVarNameOrValueMap } from './css-vars';
-import { PropertyInitMapBase } from './element-properties';
-import { HostClassesInitMap, HostClassNamesMap } from './host-classes';
-export type StylesCallbackInput<HostClassKeys extends string, CssVarKeys extends string> = {
-    hostClassSelectors: Record<HostClassKeys, CSSResult>;
-    hostClassNames: Record<HostClassKeys, CSSResult>;
-    cssVarNames: Record<CssVarKeys, CSSResult>;
-    cssVarValues: Record<CssVarKeys, CSSResult>;
-};
-export type StylesCallback<HostClassKeys extends string, CssVarKeys extends string> = (input: StylesCallbackInput<HostClassKeys, CssVarKeys>) => CSSResult;
-export declare function hostClassNamesToStylesInput<HostClassKeys extends string, CssVarKeys extends string>({ hostClassNames, cssVarNames, cssVarValues, }: {
-    hostClassNames: HostClassNamesMap<string, HostClassKeys>;
-    cssVarNames: CssVarNameOrValueMap<CssVarKeys>;
-    cssVarValues: CssVarNameOrValueMap<CssVarKeys>;
-}): StylesCallbackInput<HostClassKeys, CssVarKeys>;
-export declare function applyHostClasses<InputsGeneric extends PropertyInitMapBase, StateGeneric extends PropertyInitMapBase, HostClassKeys extends string>({ host, hostClassesInit, hostClassNames, state, inputs, }: {
-    host: HTMLElement;
-    hostClassesInit: Readonly<HostClassesInitMap<HostClassKeys, InputsGeneric, StateGeneric>> | undefined;
-    hostClassNames: HostClassNamesMap<string, HostClassKeys>;
-    state: Readonly<StateGeneric>;
-    inputs: Readonly<InputsGeneric>;
-}): void;

package/dist/declarative-element/styles.js

@@ -1,32 +0,0 @@
-import { getObjectTypedKeys, mapObjectValues } from '@augment-vir/common';
-import { unsafeCSS } from 'lit';
-export function hostClassNamesToStylesInput({ hostClassNames, cssVarNames, cssVarValues, }) {
-    return {
-        hostClassSelectors: mapObjectValues(hostClassNames, (key, name) => {
-            return unsafeCSS(`:host(.${name})`);
-        }),
-        hostClassNames: mapObjectValues(hostClassNames, (key, name) => {
-            return unsafeCSS(name);
-        }),
-        cssVarNames: cssVarNames,
-        cssVarValues: cssVarValues,
-    };
-}
-export function applyHostClasses({ host, hostClassesInit, hostClassNames, state, inputs, }) {
-    if (!hostClassesInit) {
-        return;
-    }
-    getObjectTypedKeys(hostClassesInit).forEach((hostClassKey) => {
-        const maybeCallback = hostClassesInit[hostClassKey];
-        const hostClassName = hostClassNames[hostClassKey];
-        if (typeof maybeCallback === 'function') {
-            const shouldApplyHostClass = maybeCallback({ state, inputs });
-            if (shouldApplyHostClass) {
-                host.classList.add(hostClassName);
-            }
-            else {
-                host.classList.remove(hostClassName);
-            }
-        }
-    });
-}

package/dist/declarative-element/tag-name.d.ts

@@ -1,2 +0,0 @@
-export type WithTagName<TagName extends string, Suffix extends string> = `${TagName}-${Suffix}`;
-export declare function toHtmlSafeWithTagName<TagName extends string>(tagName: TagName, forHtmlSafe: string): WithTagName<TagName, string>;

package/dist/declarative-element/tag-name.js

@@ -1,4 +0,0 @@
-import { camelCaseToKebabCase } from '@augment-vir/common';
-export function toHtmlSafeWithTagName(tagName, forHtmlSafe) {
-    return `${tagName}-${camelCaseToKebabCase(forHtmlSafe)}`;
-}

package/dist/declarative-element-marker-symbol.d.ts

@@ -1 +0,0 @@
-export declare const DeclarativeElementMarkerSymbol: unique symbol;

package/dist/declarative-element-marker-symbol.js

@@ -1 +0,0 @@
-export const DeclarativeElementMarkerSymbol = Symbol('this-is-an-element-vir-declarative-element');

package/dist/index.d.ts

@@ -1,18 +0,0 @@
-export * from './declarative-element/declarative-element';
-export * from './declarative-element/define-element';
-export * from './declarative-element/define-element-no-inputs';
-export type { DeclarativeElementDefinitionOptions } from './declarative-element/definition-options';
-export * from './declarative-element/directives/assign-with-clean-up.directive';
-export * from './declarative-element/directives/assign.directive';
-export * from './declarative-element/directives/awaiting.directive';
-export * from './declarative-element/directives/directive-helpers';
-export * from './declarative-element/directives/listen.directive';
-export * from './declarative-element/directives/on-dom-created.directive';
-export * from './declarative-element/directives/on-resize.directive';
-export * from './declarative-element/element-events';
-export * from './declarative-element/element-properties';
-export * from './declarative-element/render-callback';
-export { requireAllCustomElementsToBeDeclarativeElements } from './require-declarative-element';
-export * from './template-transforms/vir-css/vir-css';
-export * from './template-transforms/vir-html/vir-html';
-export * from './typed-event/typed-event';

package/dist/index.js

@@ -1,17 +0,0 @@
-export * from './declarative-element/declarative-element';
-export * from './declarative-element/define-element';
-export * from './declarative-element/define-element-no-inputs';
-export * from './declarative-element/directives/assign-with-clean-up.directive';
-export * from './declarative-element/directives/assign.directive';
-export * from './declarative-element/directives/awaiting.directive';
-export * from './declarative-element/directives/directive-helpers';
-export * from './declarative-element/directives/listen.directive';
-export * from './declarative-element/directives/on-dom-created.directive';
-export * from './declarative-element/directives/on-resize.directive';
-export * from './declarative-element/element-events';
-export * from './declarative-element/element-properties';
-export * from './declarative-element/render-callback';
-export { requireAllCustomElementsToBeDeclarativeElements } from './require-declarative-element';
-export * from './template-transforms/vir-css/vir-css';
-export * from './template-transforms/vir-html/vir-html';
-export * from './typed-event/typed-event';

package/dist/require-declarative-element.d.ts

@@ -1,2 +0,0 @@
-export declare let declarativeElementRequired: boolean;
-export declare function requireAllCustomElementsToBeDeclarativeElements(): void;

package/dist/require-declarative-element.js

@@ -1,4 +0,0 @@
-export let declarativeElementRequired = false;
-export function requireAllCustomElementsToBeDeclarativeElements() {
-    declarativeElementRequired = true;
-}