element-vir 7.0.0 → 7.0.1

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

@@ -0,0 +1,36 @@
+import { directive, Directive } from 'lit/directive.js';
+import { assertIsElementPartInfo } 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));
+        assertIsElementPartInfo(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]) {
+        assertIsElementPartInfo(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/directives/render-async-prop.directive.d.ts

@@ -0,0 +1,10 @@
+import { UnPromise } from '@augment-vir/common';
+import { AsyncProp } from '../properties/async-prop';
+export declare function renderAsyncProp<T>({ asyncProp, fallback, resolutionRender, errorRender, }: {
+    asyncProp: AsyncProp<T>;
+    /** This value will be rendered if the async state has not settled yet. */
+    fallback: unknown;
+    resolutionRender: (resolved: UnPromise<T>) => unknown;
+    errorRender?: (error: Error) => unknown;
+}): unknown;
+//# sourceMappingURL=render-async-prop.directive.d.ts.map

package/dist/declarative-element/directives/render-async-prop.directive.js

@@ -0,0 +1,12 @@
+import { extractErrorMessage } from '@augment-vir/common';
+export function renderAsyncProp({ asyncProp, fallback, resolutionRender, errorRender, }) {
+    if (asyncProp === null || asyncProp === void 0 ? void 0 : asyncProp.error) {
+        return errorRender ? errorRender(asyncProp.error) : extractErrorMessage(asyncProp.error);
+    }
+    else if (asyncProp === null || asyncProp === void 0 ? void 0 : asyncProp.resolution) {
+        return resolutionRender(asyncProp.resolution);
+    }
+    else {
+        return fallback;
+    }
+}

package/dist/declarative-element/directives/render-if.directive.d.ts

@@ -0,0 +1,2 @@
+export declare function renderIf<T>(condition: boolean, result: T): T | undefined;
+//# sourceMappingURL=render-if.directive.d.ts.map

package/dist/declarative-element/directives/render-if.directive.js

@@ -0,0 +1,4 @@
+import { when } from 'lit/directives/when.js';
+export function renderIf(condition, result) {
+    return when(condition, () => result);
+}

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

@@ -0,0 +1,2 @@
+export declare function hasDeclarativeElementParent(input: Element): boolean;
+//# sourceMappingURL=has-declarative-element-parent.d.ts.map

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

@@ -0,0 +1,16 @@
+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/properties/async-prop.d.ts

@@ -0,0 +1,27 @@
+import { UnPromise } from '@augment-vir/common';
+import { JsonValue } from 'type-fest';
+export type AsyncProp<ValueGeneric> = {
+    error?: Error;
+    promise?: Promise<UnPromise<ValueGeneric>>;
+    resolution?: UnPromise<ValueGeneric>;
+    isChainedAlready?: true;
+    lastTrigger?: JsonValue;
+} | undefined | null;
+declare const unsetSymbol: unique symbol;
+export declare function asyncProp<ValueGeneric>(initialValue?: UnPromise<ValueGeneric> | Promise<UnPromise<ValueGeneric>> | typeof unsetSymbol): AsyncProp<ValueGeneric>;
+export type SetAsyncPropInputs<ValueGeneric> = {
+    updateIfThisChanges?: JsonValue;
+} & ({
+    createPromise: () => Promise<UnPromise<ValueGeneric>>;
+} | {
+    resolution: UnPromise<ValueGeneric>;
+} | {
+    promise: Promise<UnPromise<ValueGeneric>>;
+});
+export declare function ensureAsyncProp<ValueGeneric, StatePropGeneric extends PropertyKey>({ state, stateProp, updateState: inputUpdateState, ...newValue }: {
+    state: Record<StatePropGeneric, AsyncProp<ValueGeneric>>;
+    stateProp: StatePropGeneric;
+    updateState: (newState: Record<StatePropGeneric, AsyncProp<ValueGeneric>>) => void;
+} & SetAsyncPropInputs<ValueGeneric>): void;
+export {};
+//# sourceMappingURL=async-prop.d.ts.map

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

@@ -0,0 +1,102 @@
+import { areJsonEqual, ensureError, isPromiseLike, typedHasProperty, } from '@augment-vir/common';
+const unsetSymbol = Symbol('unset');
+export function asyncProp(initialValue = unsetSymbol) {
+    if (initialValue === unsetSymbol) {
+        return undefined;
+    }
+    else if (isPromiseLike(initialValue)) {
+        return {
+            promise: initialValue,
+        };
+    }
+    else {
+        return {
+            resolution: initialValue,
+        };
+    }
+}
+function shouldForceUpdate(newValue, currentValue) {
+    if (!currentValue) {
+        return true;
+    }
+    if (typedHasProperty(newValue, 'updateIfThisChanges')) {
+        if (typedHasProperty(currentValue, 'lastTrigger')) {
+            return !areJsonEqual(currentValue.lastTrigger, newValue.updateIfThisChanges);
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+export function ensureAsyncProp({ state, stateProp, updateState: inputUpdateState, ...newValue }) {
+    function updateState(newStateValue) {
+        /**
+         * As cast needed here because the RecordGeneric type isn't strong enough to narrow its keys
+         * to StatePropGeneric, it just thinks they're all strings
+         */
+        inputUpdateState({ [stateProp]: newStateValue });
+    }
+    const forceUpdate = shouldForceUpdate(newValue, state[stateProp]);
+    const currentValue = forceUpdate ? undefined : state[stateProp];
+    if (currentValue === null || currentValue === void 0 ? void 0 : currentValue.error) {
+        // abort if there's an error
+        return;
+    }
+    if (currentValue && 'resolution' in currentValue) {
+        // abort if the async value has already been resolved
+        return;
+    }
+    const lastTriggerObject = typedHasProperty(newValue, 'updateIfThisChanges')
+        ? { lastTrigger: newValue.updateIfThisChanges }
+        : {};
+    // if given a resolution value, set that
+    if ('resolution' in newValue) {
+        return updateState({
+            resolution: newValue.resolution,
+            ...lastTriggerObject,
+        });
+    }
+    // if there is no promise or resolution, set a promise
+    const needsNewPromise = currentValue == undefined || !('promise' in currentValue);
+    const needsChaining = currentValue == undefined || !currentValue.isChainedAlready;
+    if (!needsNewPromise && !needsChaining) {
+        // abort, there is nothing to do
+        return;
+    }
+    const newPromise = needsNewPromise
+        ? 'promise' in newValue
+            ? newValue.promise
+            : 'createPromise' in newValue
+                ? newValue.createPromise()
+                : undefined
+        : undefined;
+    if (needsNewPromise && !newPromise) {
+        throw new Error(`Was not able to create a new promise for state.${String(stateProp)}: missing "promise" or "createPromise" key for ${ensureAsyncProp.name}`);
+    }
+    const promiseToChain = newPromise !== null && newPromise !== void 0 ? newPromise : currentValue === null || currentValue === void 0 ? void 0 : currentValue.promise;
+    if (!promiseToChain) {
+        // at this point there is definitely a promise to chain
+        throw new Error('Failed to find promise to chain.');
+    }
+    promiseToChain
+        .then((value) => {
+        updateState({
+            promise: promiseToChain,
+            resolution: value,
+            ...lastTriggerObject,
+        });
+    })
+        .catch((error) => {
+        updateState({
+            promise: promiseToChain,
+            error: ensureError(error),
+            ...lastTriggerObject,
+        });
+    });
+    updateState({
+        promise: promiseToChain,
+        isChainedAlready: true,
+        ...lastTriggerObject,
+    });
+}

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

@@ -0,0 +1,7 @@
+import { CSSResult } from 'lit';
+export type CssVarsInitMap<CssVarKeys extends string> = Record<CssVarKeys, string | CSSResult>;
+export type CssVarName<TagName extends string> = `--${TagName}-string`;
+export type CssVarNameOrValueMap<CssVarKeys extends string> = Record<CssVarKeys, CSSResult>;
+export declare function createCssVarNamesMap<TagName extends string, CssVarKeys extends string>(tagName: TagName, cssVarsInit: CssVarsInitMap<CssVarKeys> | undefined): CssVarNameOrValueMap<CssVarKeys>;
+export declare function createCssVarValuesMap<CssVarKeys extends string>(cssVarInitMap: CssVarsInitMap<CssVarKeys> | undefined, cssVarNamesMap: CssVarNameOrValueMap<CssVarKeys>): CssVarNameOrValueMap<CssVarKeys>;
+//# sourceMappingURL=css-vars.d.ts.map

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

@@ -0,0 +1,22 @@
+import { mapObjectValues } from '@augment-vir/common';
+import { unsafeCSS } from 'lit';
+import { toHtmlSafeWithTagName } from './tag-name';
+export function createCssVarNamesMap(tagName, cssVarsInit) {
+    if (cssVarsInit) {
+        return mapObjectValues(cssVarsInit, (key) => {
+            return unsafeCSS(`--${toHtmlSafeWithTagName(tagName, String(key))}`);
+        });
+    }
+    else {
+        return {};
+    }
+}
+export function createCssVarValuesMap(cssVarInitMap, cssVarNamesMap) {
+    if (!cssVarInitMap) {
+        return {};
+    }
+    return mapObjectValues(cssVarInitMap, (key, fallbackValue) => {
+        const name = cssVarNamesMap[key];
+        return unsafeCSS(`var(${name}, ${fallbackValue})`);
+    });
+}

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

@@ -0,0 +1,11 @@
+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>;
+//# sourceMappingURL=element-events.d.ts.map

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

@@ -0,0 +1,24 @@
+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/properties/element-properties.d.ts

@@ -0,0 +1,15 @@
+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 createPropertyDescriptorMap<PropertyInitGeneric extends PropertyInitMapBase>(propertyInit: PropertyInitGeneric | undefined): ElementPropertyDescriptorMap<PropertyInitGeneric>;
+//# sourceMappingURL=element-properties.d.ts.map

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

@@ -0,0 +1,21 @@
+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/properties/element-updater-proxy.d.ts

@@ -0,0 +1,4 @@
+import { DeclarativeElement } from '../declarative-element';
+import { PropertyInitMapBase } from './element-properties';
+export declare function createElementUpdaterProxy<PropertyInitGeneric extends PropertyInitMapBase>(element: DeclarativeElement, verifyExists: boolean): PropertyInitGeneric;
+//# sourceMappingURL=element-updater-proxy.d.ts.map

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

@@ -0,0 +1,56 @@
+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);
+            }
+            return elementAsProps[propertyName];
+        },
+        set: (target, propertyName, newValue) => {
+            if (verifyExists) {
+                assertValidPropertyName(propertyName, element, element.tagName);
+            }
+            /**
+             * Don't worry about storing the value (no need to have duplicates of teh values) but at
+             * least set the property on target so we can detect it in "ownKeys" and
+             * "getOwnPropertyDescriptor".
+             */
+            target[propertyName] = undefined;
+            elementAsProps[propertyName] = newValue;
+            return true;
+        },
+        ownKeys: (target) => {
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, propertyName) {
+            if (propertyName in target) {
+                return {
+                    get value() {
+                        return elementAsProps[propertyName];
+                    },
+                    configurable: true,
+                    enumerable: true,
+                };
+            }
+            return undefined;
+        },
+        has: (target, propertyName) => {
+            return Reflect.has(target, propertyName);
+        },
+    });
+    return propsProxy;
+}

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

@@ -0,0 +1,22 @@
+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>;
+//# sourceMappingURL=host-classes.d.ts.map

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

@@ -0,0 +1,12 @@
+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/properties/styles.d.ts

@@ -0,0 +1,24 @@
+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;
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1,32 @@
+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/properties/tag-name.d.ts

@@ -0,0 +1,3 @@
+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>;
+//# sourceMappingURL=tag-name.d.ts.map

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

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

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

@@ -0,0 +1,27 @@
+import { TemplateResult } from 'lit';
+import { TypedEvent } from '../typed-event/typed-event';
+import { DeclarativeElement, HostInstanceType } from './declarative-element';
+import { AsyncProp, SetAsyncPropInputs } from './properties/async-prop';
+import { EventDescriptorMap, EventInitMapEventDetailExtractor, EventsInitMap } from './properties/element-events';
+import { PropertyInitMapBase } from './properties/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>> | Event) => boolean;
+    inputs: InputsGeneric;
+    /**
+     * Updates async props in the state if they have not already been set. Once promises settle,
+     * this automatically updates the state. In order to re-trigger an async prop, set it to
+     * undefined first.
+     */
+    ensureAsyncProp: (values: Partial<{
+        [StateKey in keyof StateInitGeneric as StateInitGeneric[StateKey] extends AsyncProp<any> ? StateKey : never]: StateInitGeneric[StateKey] extends AsyncProp<infer ValueGeneric> ? SetAsyncPropInputs<ValueGeneric> : never;
+    }>) => void;
+};
+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>;
+//# sourceMappingURL=render-callback.d.ts.map

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

@@ -0,0 +1,31 @@
+import { getObjectTypedKeys } from '@augment-vir/common';
+import { ensureAsyncProp } from './properties/async-prop';
+export function createRenderParams(element, eventsMap) {
+    function updateState(partialProps) {
+        getObjectTypedKeys(partialProps).forEach((propKey) => {
+            element.instanceState[propKey] = partialProps[propKey];
+        });
+    }
+    const renderParams = {
+        dispatch: (event) => element.dispatchEvent(event),
+        updateState,
+        inputs: element.instanceInputs,
+        host: element,
+        state: element.instanceState,
+        events: eventsMap,
+        ensureAsyncProp: (values) => {
+            Object.entries(values).forEach(([stateKey, newSet,]) => {
+                if (!(stateKey in element.instanceState)) {
+                    throw new Error(`Invalid key given to ensureAsyncProp: ${stateKey}`);
+                }
+                ensureAsyncProp({
+                    state: element.instanceState,
+                    updateState: updateState,
+                    stateProp: stateKey,
+                    ...newSet,
+                });
+            });
+        },
+    };
+    return renderParams;
+}

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

@@ -0,0 +1,2 @@
+export declare const DeclarativeElementMarkerSymbol: unique symbol;
+//# sourceMappingURL=declarative-element-marker-symbol.d.ts.map

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

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

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+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/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/directives/render-async-prop.directive';
+export * from './declarative-element/directives/render-if.directive';
+export * from './declarative-element/properties/async-prop';
+export * from './declarative-element/properties/element-events';
+export * from './declarative-element/properties/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';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,19 @@
+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/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/directives/render-async-prop.directive';
+export * from './declarative-element/directives/render-if.directive';
+export * from './declarative-element/properties/async-prop';
+export * from './declarative-element/properties/element-events';
+export * from './declarative-element/properties/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

@@ -0,0 +1,3 @@
+export declare let declarativeElementRequired: boolean;
+export declare function requireAllCustomElementsToBeDeclarativeElements(): void;
+//# sourceMappingURL=require-declarative-element.d.ts.map

package/dist/require-declarative-element.js

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

package/dist/template-transforms/has-static-tag-name.d.ts

@@ -0,0 +1,5 @@
+export type ConstructorWithTagName = Function & {
+    tagName: string;
+};
+export declare function hasStaticTagName(value: unknown): value is ConstructorWithTagName;
+//# sourceMappingURL=has-static-tag-name.d.ts.map