element-vir 26.11.2 → 26.12.0

package/dist/readme-examples/my-with-custom-events.element.js

@@ -1,22 +0,0 @@
-import { randomInteger } from '@augment-vir/common';
-import { defineElement } from 'element-vir';
-import { html, listen } from '../index.js';
-import { MyCustomActionEvent } from './my-custom-action.event.js';
-export const MyWithCustomEvents = defineElement()({
-    tagName: 'my-with-custom-events',
-    render({ dispatch }) {
-        return html `
-            <div
-                ${listen(MyCustomActionEvent, (event) => {
-            console.info(`Got a number! ${event.detail}`);
-        })}
-            >
-                <div
-                    ${listen('click', () => {
-            dispatch(new MyCustomActionEvent(randomInteger({ min: 0, max: 1_000_000 })));
-        })}
-                ></div>
-            </div>
-        `;
-    },
-});

package/dist/readme-examples/my-with-event-listening.element.d.ts

@@ -1,3 +0,0 @@
-export declare const MyWithEventListening: import("element-vir").DeclarativeElementDefinition<"my-with-event-listening", {}, {
-    myNumber: number;
-}, {}, "my-with-event-listening-", "my-with-event-listening-", readonly [], readonly []>;

package/dist/readme-examples/my-with-events.element.d.ts

@@ -1,4 +0,0 @@
-export declare const MyWithEvents: import("element-vir").DeclarativeElementDefinition<"my-with-events", {}, {}, {
-    logoutClick: import("element-vir").DefineEvent<void>;
-    randomNumber: import("element-vir").DefineEvent<number>;
-}, "my-with-events-", "my-with-events-", readonly [], readonly []>;

package/dist/readme-examples/my-with-events.element.js

@@ -1,20 +0,0 @@
-import { randomInteger } from '@augment-vir/common';
-import { defineElement } from 'element-vir';
-import { defineElementEvent, html, listen } from '../index.js';
-export const MyWithEvents = defineElement()({
-    tagName: 'my-with-events',
-    events: {
-        logoutClick: defineElementEvent(),
-        randomNumber: defineElementEvent(),
-    },
-    render({ dispatch, events }) {
-        return html `
-            <button ${listen('click', () => dispatch(new events.logoutClick()))}>log out</button>
-            <button
-                ${listen('click', () => dispatch(new events.randomNumber(randomInteger({ min: 0, max: 1_000_000 }))))}
-            >
-                generate random number
-            </button>
-        `;
-    },
-});

package/dist/readme-examples/my-with-host-class-definition.element.d.ts

@@ -1,3 +0,0 @@
-export declare const MyWithHostClassDefinition: import("element-vir").DeclarativeElementDefinition<"my-with-host-class-definition", {}, {
-    myProp: string;
-}, {}, "my-with-host-class-definition-a" | "my-with-host-class-definition-automatic", "my-with-host-class-definition-", readonly [], readonly []>;

package/dist/readme-examples/my-with-host-class-usage.element.d.ts

@@ -1 +0,0 @@
-export declare const MyWithHostClassUsage: import("element-vir").DeclarativeElementDefinition<"my-with-host-class-usage", {}, {}, {}, "my-with-host-class-usage-", "my-with-host-class-usage-", readonly [], readonly []>;

package/dist/readme-examples/my-with-inputs.element.d.ts

@@ -1,4 +0,0 @@
-export declare const MyWithInputs: import("../index.js").DeclarativeElementDefinition<"my-with-inputs", {
-    username: string;
-    email: string;
-}, {}, {}, "my-with-inputs-", "my-with-inputs-", readonly [], readonly []>;

package/dist/readme-examples/my-with-inputs.element.js

@@ -1,9 +0,0 @@
-import { defineElement, html } from '../index.js';
-export const MyWithInputs = defineElement()({
-    tagName: 'my-with-inputs',
-    render({ inputs }) {
-        return html `
-            <span>Hello there ${inputs.username}!</span>
-        `;
-    },
-});

package/dist/readme-examples/my-with-on-dom-created.element.d.ts

@@ -1 +0,0 @@
-export declare const MyWithOnDomCreated: import("element-vir").DeclarativeElementDefinition<"my-with-on-dom-created", {}, {}, {}, "my-with-on-dom-created-", "my-with-on-dom-created-", readonly [], readonly []>;

package/dist/readme-examples/my-with-on-resize.element.d.ts

@@ -1 +0,0 @@
-export declare const MyWithOnResize: import("element-vir").DeclarativeElementDefinition<"my-with-on-resize", {}, {}, {}, "my-with-on-resize-", "my-with-on-resize-", readonly [], readonly []>;

package/dist/readme-examples/my-with-on-resize.element.js

@@ -1,18 +0,0 @@
-import { defineElement } from 'element-vir';
-import { html, onResize } from '../index.js';
-export const MyWithOnResize = defineElement()({
-    tagName: 'my-with-on-resize',
-    render() {
-        return html `
-            <span
-                ${onResize((entry) => {
-            // this will track resizing of this span
-            // the entry parameter contains target and contentRect properties
-            console.info(entry);
-        })}
-            >
-                Hello there!
-            </span>
-        `;
-    },
-});

package/dist/readme-examples/my-with-render-if.element.d.ts

@@ -1,3 +0,0 @@
-export declare const MyWithRenderIf: import("../index.js").DeclarativeElementDefinition<"my-with-render-if", {
-    shouldRender: boolean;
-}, {}, {}, "my-with-render-if-", "my-with-render-if-", readonly [], readonly []>;

package/dist/readme-examples/my-with-render-if.element.js

@@ -1,11 +0,0 @@
-import { defineElement, html, renderIf } from '../index.js';
-export const MyWithRenderIf = defineElement()({
-    tagName: 'my-with-render-if',
-    render({ inputs }) {
-        return html `
-            ${renderIf(inputs.shouldRender, html `
-                    I'm conditionally rendered!
-                `)}
-        `;
-    },
-});

package/dist/readme-examples/my-with-styles-and-interpolated-selector.element.d.ts

@@ -1 +0,0 @@
-export declare const MyWithStylesAndInterpolatedSelector: import("element-vir").DeclarativeElementDefinition<"my-with-styles-and-interpolated-selector", {}, {}, {}, "my-with-styles-and-interpolated-selector-", "my-with-styles-and-interpolated-selector-", readonly [], readonly []>;

package/dist/readme-examples/my-with-styles.element.d.ts

@@ -1 +0,0 @@
-export declare const MyWithStyles: import("element-vir").DeclarativeElementDefinition<"my-with-styles", {}, {}, {}, "my-with-styles-", "my-with-styles-", readonly [], readonly []>;

package/dist/readme-examples/my-with-update-state.element.d.ts

@@ -1,8 +0,0 @@
-export declare const MyWithUpdateState: import("element-vir").DeclarativeElementDefinition<"my-with-update-state", {}, {
-    username: string;
-    /**
-     * Use "as" to create state properties that can be types other than the initial value's
-     * type. This is particularly useful when, as below, the initial value is undefined.
-     */
-    email: string | undefined;
-}, {}, "my-with-update-state-", "my-with-update-state-", readonly [], readonly []>;

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

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

package/dist/readme-examples/require-declarative-element.js

@@ -1,2 +0,0 @@
-import { requireAllCustomElementsToBeDeclarativeElements } from '../index.js';
-requireAllCustomElementsToBeDeclarativeElements();

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

@@ -1,14 +0,0 @@
-/**
- * Set by {@link requireAllCustomElementsToBeDeclarativeElements} and read in the HTML tagged
- * template function.
- *
- * @category Internal
- */
-export declare let declarativeElementRequired: boolean;
-/**
- * Calling this requires all custom element children to be declarative elements defined by
- * element-vir.
- *
- * @category Util
- */
-export declare function requireAllCustomElementsToBeDeclarativeElements(): void;

package/dist/template-transforms/minimal-element-definition.js

@@ -1,19 +0,0 @@
-import { check } from '@augment-vir/assert';
-/**
- * Checks if the input is an instance of {@link MinimalDefinitionWithInputs}.
- *
- * @category Internal
- */
-export function isMinimalDefinitionWithInputs(value) {
-    return (check.hasKey(value, '_elementVirIsMinimalDefinitionWithInputs') &&
-        !!value._elementVirIsMinimalDefinitionWithInputs);
-}
-/**
- * Checks if the input is an object that has a `tagName` property. Used inside of the HTML tagged
- * template functions for checking if interpolated values should be treated as element tags.
- *
- * @category Internal
- */
-export function hasTagName(value) {
-    return check.hasKey(value, 'tagName') && !!value.tagName && typeof value.tagName === 'string';
-}

package/dist/template-transforms/nested-mapped-templates.d.ts

@@ -1,6 +0,0 @@
-import { type TemplateTransform } from './template-transform-type.js';
-export declare function getAlreadyMappedTemplate<PossibleValues>(templateStringsKey: TemplateStringsArray, values: PossibleValues[]): TemplateTransform | undefined;
-export declare function setMappedTemplate<PossibleValues>(templateStringsKey: TemplateStringsArray, values: PossibleValues[], valueToSet: TemplateTransform): {
-    result: boolean;
-    reason: string;
-};

package/dist/template-transforms/nested-mapped-templates.js

@@ -1,96 +0,0 @@
-import { check } from '@augment-vir/assert';
-import { filterMap } from '@augment-vir/common';
-import { hasTagName, isMinimalDefinitionWithInputs } from './minimal-element-definition.js';
-function extractElementKeys(values) {
-    return filterMap(values, (value) => {
-        if (isMinimalDefinitionWithInputs(value)) {
-            return value.definition;
-        }
-        if (hasTagName(value)) {
-            return value.tagInterpolationKey || value;
-        }
-        return undefined;
-    }, check.isTruthy);
-}
-/**
- * The transformed templates are written to a map so that we can preserve reference equality between
- * calls. Without maintaining reference equality between html`` calls, lit-element reconstructs all
- * of its children on every render.
- *
- * This is a WeakMap because we only care about the transformed array value as long as the original
- * template array key exists.
- */
-const transformedTemplateStrings = new WeakMap();
-export function getAlreadyMappedTemplate(templateStringsKey, values) {
-    const elementKeys = extractElementKeys(values);
-    const nestedValue = getNestedValues(transformedTemplateStrings, [
-        templateStringsKey,
-        ...elementKeys,
-    ]);
-    return nestedValue.value?.template;
-}
-export function setMappedTemplate(templateStringsKey, values, valueToSet) {
-    const elementKeys = extractElementKeys(values);
-    return setNestedValues(transformedTemplateStrings, [
-        templateStringsKey,
-        ...elementKeys,
-    ], valueToSet);
-}
-function getNestedValues(map, keys, index = 0) {
-    const { currentTemplateAndNested, reason } = getCurrentKeyAndValue(map, keys, index);
-    if (!currentTemplateAndNested) {
-        return { value: currentTemplateAndNested, reason };
-    }
-    if (index === keys.length - 1) {
-        return { value: currentTemplateAndNested, reason: `reached end of keys array` };
-    }
-    if (!currentTemplateAndNested.nested) {
-        return { value: undefined, reason: `map at key index ${index} did not have nested maps` };
-    }
-    return getNestedValues(currentTemplateAndNested.nested, keys, index + 1);
-}
-function getCurrentKeyAndValue(map, keys, index) {
-    const currentKey = keys[index];
-    if (currentKey == undefined) {
-        return {
-            currentKey: undefined,
-            currentTemplateAndNested: undefined,
-            reason: `key at index ${index} not found`,
-        };
-    }
-    if (!map.has(currentKey)) {
-        return {
-            currentKey,
-            currentTemplateAndNested: undefined,
-            reason: `key at index ${index} was not in the map`,
-        };
-    }
-    const currentTemplateAndNested = map.get(currentKey);
-    if (currentTemplateAndNested == undefined) {
-        return {
-            currentKey,
-            currentTemplateAndNested: undefined,
-            reason: `value at key at index ${index} was undefined`,
-        };
-    }
-    return { currentKey, currentTemplateAndNested, reason: `key and value exists` };
-}
-function setNestedValues(map, keys, valueToSet, index = 0) {
-    const { currentTemplateAndNested, currentKey, reason } = getCurrentKeyAndValue(map, keys, index);
-    if (!currentKey) {
-        return { result: false, reason };
-    }
-    const nestedAndTemplate = currentTemplateAndNested ?? { nested: undefined, template: undefined };
-    if (!currentTemplateAndNested) {
-        map.set(currentKey, nestedAndTemplate);
-    }
-    if (index === keys.length - 1) {
-        nestedAndTemplate.template = valueToSet;
-        return { result: true, reason: `set value at end of keys array` };
-    }
-    const nestedWeakMap = nestedAndTemplate.nested ?? new WeakMap();
-    if (!nestedAndTemplate.nested) {
-        nestedAndTemplate.nested = nestedWeakMap;
-    }
-    return setNestedValues(nestedWeakMap, keys, valueToSet, index + 1);
-}

package/dist/template-transforms/template-transform-type.js

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

package/dist/template-transforms/transform-template.d.ts

@@ -1,14 +0,0 @@
-import { type TemplateTransform } from './template-transform-type.js';
-export type ValueInsertion = {
-    index: number;
-    value: unknown;
-};
-export type ValueTransformCallback = (lastNewString: string, currentLitString: string, currentValue: unknown) => {
-    replacement: unknown;
-    getExtraValues: ((currentValue: unknown) => unknown[]) | undefined;
-} | undefined;
-export declare function getTransformedTemplate<PossibleValues>(templateStringsKey: TemplateStringsArray, values: PossibleValues[], fallbackTransform: () => TemplateTransform): {
-    strings: TemplateStringsArray;
-    values: PossibleValues[];
-};
-export declare function transformTemplate<PossibleValues>(inputTemplateStrings: TemplateStringsArray, inputValues: PossibleValues[], transformValue: ValueTransformCallback, assertValidString?: (templateStringPart: string) => void): TemplateTransform;

package/dist/template-transforms/vir-css/css-transform.d.ts

@@ -1,4 +0,0 @@
-import { type CSSResultGroup } from '../../lit-exports/all-lit-exports.js';
-import { type MinimalElementDefinition } from '../minimal-element-definition.js';
-import { type TemplateTransform } from '../template-transform-type.js';
-export declare function transformCssTemplate(inputTemplateStrings: TemplateStringsArray, inputValues: (number | CSSResultGroup | MinimalElementDefinition)[]): TemplateTransform;

package/dist/template-transforms/vir-css/css-transform.js

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { hasTagName } from '../minimal-element-definition.js';
-import { transformTemplate } from '../transform-template.js';
-function transformCss(...[lastNewString, currentLitString, currentValue,]) {
-    if (!hasTagName(currentValue)) {
-        return undefined;
-    }
-    return {
-        replacement: currentValue.tagName,
-        getExtraValues: undefined,
-    };
-}
-export function transformCssTemplate(inputTemplateStrings, inputValues) {
-    return transformTemplate(inputTemplateStrings, inputValues, transformCss);
-}

package/dist/template-transforms/vir-css/vir-css.d.ts

@@ -1,12 +0,0 @@
-import { type CSSResult, type CSSResultGroup } from '../../lit-exports/all-lit-exports.js';
-import { type MinimalElementDefinition } from '../minimal-element-definition.js';
-/**
- * A template literal tag used to define styles for element definitions. In particular, this is used
- * for the `styles` property in an element definitions init object.
- *
- * For security reasons, only literal string or number values may be interpolated inside of this
- * taggedTemplate. To incorporate non-literal values, wrap the value in a call to `unsafeCSS`.
- *
- * @category Element Definition
- */
-export declare function css(inputTemplateStrings: TemplateStringsArray, ...inputValues: (number | CSSResultGroup | MinimalElementDefinition | CSSResult)[]): CSSResult;

package/dist/template-transforms/vir-css/vir-css.js

@@ -1,21 +0,0 @@
-import { css as litCss } from 'lit';
-import { getTransformedTemplate } from '../transform-template.js';
-import { transformCssTemplate } from './css-transform.js';
-/**
- * A template literal tag used to define styles for element definitions. In particular, this is used
- * for the `styles` property in an element definitions init object.
- *
- * For security reasons, only literal string or number values may be interpolated inside of this
- * taggedTemplate. To incorporate non-literal values, wrap the value in a call to `unsafeCSS`.
- *
- * @category Element Definition
- */
-export function css(inputTemplateStrings, ...inputValues) {
-    const transformedTemplate = getTransformedTemplate(inputTemplateStrings, inputValues, () => {
-        return transformCssTemplate(inputTemplateStrings, inputValues);
-    });
-    const cssResult = litCss(transformedTemplate.strings, 
-    /** The filter will remove the DeclarativeElement elements */
-    ...transformedTemplate.values);
-    return cssResult;
-}

package/dist/template-transforms/vir-html/html-interpolation.d.ts

@@ -1,42 +0,0 @@
-import { type AnyFunction, type Overwrite } from '@augment-vir/common';
-import { type CSSResult, type TemplateResult, type nothing } from 'lit';
-import { type EmptyObject, type HasRequiredKeys, type IsNever } from 'type-fest';
-import { type DeclarativeElementDefinition } from '../../declarative-element/declarative-element.js';
-import { type Decrement, type Increment } from '../../util/increment.js';
-import { type MinimalDefinitionWithInputs, type MinimalElementDefinition } from '../minimal-element-definition.js';
-/**
- * Unfortunately the type for `DirectiveResult` means it's just an empty object. So in order to
- * block actual objects, we have to narrow `DirectiveResult` further to this empty object type.
- *
- * @category Internal
- */
-export type DirectiveOutput = EmptyObject;
-/**
- * This is used in order to block accidental object interpolations into HTML, which get stringified
- * into `'[object Object]'`, which nobody ever wants that.
- *
- * @category Internal
- */
-export type HtmlInterpolation = null | undefined | string | number | boolean | bigint | CSSResult | Readonly<CSSResult> | Element | Readonly<Element> | TemplateResult | Readonly<TemplateResult> | MinimalElementDefinition | Readonly<MinimalElementDefinition> | MinimalDefinitionWithInputs | Readonly<MinimalDefinitionWithInputs> | DeclarativeElementDefinition | Readonly<DeclarativeElementDefinition> | DirectiveOutput | Readonly<DirectiveOutput> | AnyFunction | typeof nothing | HtmlInterpolation[] | ReadonlyArray<HtmlInterpolation>;
-/**
- * This type ensures that interpolated element definitions are not missing their inputs, when inputs
- * are required.
- *
- * @category Internal
- */
-export type VerifyHtmlValues<Values extends HtmlInterpolation[], WaitingForEndTags extends Record<string, number> = {}> = Values extends [
-    infer CurrentDefinition extends DeclarativeElementDefinition,
-    ...infer Rest extends HtmlInterpolation[]
-] ? CurrentDefinition extends DeclarativeElementDefinition<infer TagName, infer Inputs> ? HasRequiredKeys<Inputs> extends true ? IsNever<Decrement<WaitingForEndTags[TagName]>> extends true ? [
-    `ERROR: This element is missing its inputs.`,
-    ...VerifyHtmlValues<Rest, WaitingForEndTags>
-] : [
-    CurrentDefinition,
-    ...VerifyHtmlValues<Rest, Overwrite<WaitingForEndTags, Record<TagName, Decrement<WaitingForEndTags[TagName]>>>>
-] : [CurrentDefinition, ...VerifyHtmlValues<Rest, WaitingForEndTags>] : [CurrentDefinition, ...VerifyHtmlValues<Rest, WaitingForEndTags>] : Values extends [
-    infer CurrentDefinition extends MinimalDefinitionWithInputs,
-    ...infer Rest extends HtmlInterpolation[]
-] ? [
-    CurrentDefinition,
-    ...VerifyHtmlValues<Rest, Overwrite<WaitingForEndTags, Record<CurrentDefinition['definition']['tagName'], Increment<WaitingForEndTags[CurrentDefinition['definition']['tagName']]>>>>
-] : Values;

package/dist/template-transforms/vir-html/html-interpolation.js

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

package/dist/template-transforms/vir-html/html-transform.d.ts

@@ -1,5 +0,0 @@
-import { type HTMLTemplateResult } from '../../lit-exports/all-lit-exports.js';
-import { type TemplateTransform } from '../template-transform-type.js';
-import { type HtmlInterpolation } from './html-interpolation.js';
-export declare function mapHtmlValues(inputTemplateStrings: TemplateStringsArray, inputValues: HtmlInterpolation[]): HtmlInterpolation[];
-export declare function transformHtmlTemplate(litTemplate: HTMLTemplateResult): TemplateTransform;

package/dist/template-transforms/vir-html/html-transform.js

@@ -1,96 +0,0 @@
-/* eslint-disable @typescript-eslint/no-deprecated */
-import { check } from '@augment-vir/assert';
-import { collapseWhiteSpace, getOrSet, safeMatch } from '@augment-vir/common';
-import { assign } from '../../declarative-element/directives/assign.directive.js';
-import { declarativeElementRequired } from '../../require-declarative-element.js';
-import { hasTagName, isMinimalDefinitionWithInputs, } from '../minimal-element-definition.js';
-import { transformTemplate } from '../transform-template.js';
-import { tagNameKeys } from './tag-name-keys.js';
-export function mapHtmlValues(inputTemplateStrings, inputValues) {
-    return inputValues.map((currentValue, currentValueIndex) => {
-        const lastString = inputTemplateStrings[currentValueIndex];
-        const nextString = inputTemplateStrings[currentValueIndex + 1];
-        if (lastString && nextString) {
-            const { shouldHaveTagNameHere } = classifyValue(lastString, nextString);
-            if (shouldHaveTagNameHere && check.isString(currentValue)) {
-                const replacement = {
-                    tagName: currentValue,
-                    tagInterpolationKey: getOrSet(tagNameKeys, currentValue, () => {
-                        return { tagName: currentValue };
-                    }),
-                };
-                return replacement;
-            }
-        }
-        return currentValue;
-    });
-}
-function classifyValue(lastNewString, currentTemplateString) {
-    const isOpeningTag = lastNewString.trim().endsWith('<') && !!currentTemplateString.match(/^[\s>]/);
-    const isClosingTag = lastNewString.trim().endsWith('</') && currentTemplateString.trim().startsWith('>');
-    const shouldHaveTagNameHere = isOpeningTag || isClosingTag;
-    return {
-        isOpeningTag,
-        shouldHaveTagNameHere,
-    };
-}
-function transformHtml(...[lastNewString, currentTemplateString, rawCurrentValue,]) {
-    const currentValue = isMinimalDefinitionWithInputs(rawCurrentValue)
-        ? rawCurrentValue.definition
-        : rawCurrentValue;
-    const { isOpeningTag, shouldHaveTagNameHere } = classifyValue(lastNewString, currentTemplateString);
-    const isTagNameWrapper = hasTagName(currentValue);
-    if (isTagNameWrapper && shouldHaveTagNameHere && currentValue.tagInterpolationKey) {
-        return {
-            replacement: currentValue.tagName,
-            getExtraValues: undefined,
-        };
-    }
-    if (shouldHaveTagNameHere && !isTagNameWrapper) {
-        console.error({
-            lastNewString,
-            currentTemplateString,
-            currentValue,
-        });
-        throw new Error(`Got interpolated tag name but found no tag name on the given value: '${currentValue?.tagName ||
-            currentValue?.prototype?.constructor?.name ||
-            currentValue?.constructor?.name}'`);
-    }
-    if (!shouldHaveTagNameHere || !isTagNameWrapper) {
-        return undefined;
-    }
-    const replacement = currentValue.tagName;
-    return {
-        replacement,
-        getExtraValues(extraValueCurrentValue) {
-            const assignedInputs = isMinimalDefinitionWithInputs(extraValueCurrentValue)
-                ? extraValueCurrentValue.inputs
-                : undefined;
-            return [
-                isOpeningTag && assignedInputs ? assign(assignedInputs) : undefined,
-            ].filter(check.isTruthy);
-        },
-    };
-}
-function extractCustomElementTags(input) {
-    const tagNameMatches = safeMatch(input, /<\/\s*[^\s><]+\s*>/g);
-    return tagNameMatches.reduce((accum, match) => {
-        const tagName = collapseWhiteSpace(match.replace(/\n/g, ' ')).replace(/<\/|>/g, '');
-        // custom elements always have a dash in them
-        if (tagName.includes('-')) {
-            return accum.concat(tagName);
-        }
-        return accum;
-    }, []);
-}
-function stringValidator(input) {
-    if (declarativeElementRequired) {
-        const customElementTagNames = extractCustomElementTags(input);
-        if (customElementTagNames.length) {
-            console.error(`Custom element tags must be interpolated from declarative elements: ${customElementTagNames.join(', ')}`);
-        }
-    }
-}
-export function transformHtmlTemplate(litTemplate) {
-    return transformTemplate(litTemplate.strings, litTemplate.values, transformHtml, stringValidator);
-}

package/dist/template-transforms/vir-html/tag-name-keys.d.ts

@@ -1,7 +0,0 @@
-/**
- * Used to create objects for each interpolated tag name string (tag names that aren't wrapped in a
- * `DeclarativeElementDefinition`) so that we can use them as keys for the mapped template weakmap.
- */
-export declare const tagNameKeys: Record<string, {
-    tagName: string;
-}>;

package/dist/template-transforms/vir-html/vir-html.d.ts

@@ -1,11 +0,0 @@
-import { type HTMLTemplateResult } from '../../lit-exports/all-lit-exports.js';
-import { type HtmlInterpolation, type VerifyHtmlValues } from './html-interpolation.js';
-/**
- * Interprets a template literal as an HTML template which is lazily rendered to the DOM.
- *
- * Wraps lit-html's html tagged template and enables interpolations of
- * `DeclarativeElementDefinition` for tag names.
- *
- * @category Element Definition
- */
-export declare function html<const Values extends HtmlInterpolation[]>(inputTemplateStrings: TemplateStringsArray, ...inputValues: VerifyHtmlValues<Values>): HTMLTemplateResult;

package/dist/typed-event/typed-event.d.ts

@@ -1,55 +0,0 @@
-import { type NonEmptyString } from '../util/type.js';
-/**
- * A custom event with strict types for details and the event's `type` property.
- *
- * @category Internal
- */
-export declare class TypedEvent<EventTypeNameGeneric extends string = '', EventDetailGeneric = undefined> extends CustomEvent<EventDetailGeneric> {
-    readonly _type: EventTypeNameGeneric;
-    get type(): EventTypeNameGeneric;
-    constructor(type: EventTypeNameGeneric | {
-        type: EventTypeNameGeneric;
-    }, value: EventDetailGeneric);
-}
-/**
- * A function that defines a typed event, used for defining element events in an element's
- * definition.
- *
- * @category Internal
- */
-export type DefineEvent<EventDetailGeneric> = <EventTypeNameGeneric extends string>(eventType: NonEmptyString<EventTypeNameGeneric>) => DefinedTypedEvent<EventTypeNameGeneric, EventDetailGeneric>;
-/**
- * A concrete typed event definition.
- *
- * @category Internal
- */
-export type DefinedTypedEvent<EventTypeNameGeneric extends string, EventDetailGeneric> = (new (eventValue: EventDetailGeneric) => TypedEvent<EventTypeNameGeneric, EventDetailGeneric>) & {
-    type: EventTypeNameGeneric;
-};
-/**
- * Define a stand-alone typed event that can be emitted and listened to inside of HTML templates.
- *
- * Make sure to use currying and call this function twice! (This is required by TypeScript's type
- * parameter inference system.)
- *
- * @category Element Definition
- * @example
- *
- * ```ts
- * import {defineTypedEvent} from 'element-vir';
- *
- * const myCustomEvent = defineTypedEvent<number>()('my-custom-event');
- *
- * const myCustomEvent2 = defineTypedEvent<// the event's `.detail` type
- * number>()(
- *     // the event's `.type` string
- *     'my-custom-event2',
- * );
- * ```
- */
-export declare function defineTypedEvent<EventDetailGeneric>(): <
-/**
- * EventTypeNameGeneric is used for the event type property but not for the event value
- * type... so it's named "name" instead of "type" cause type is overloaded here.
- */
-EventTypeNameGeneric extends string>(eventType: NonEmptyString<EventTypeNameGeneric>) => DefinedTypedEvent<EventTypeNameGeneric, EventDetailGeneric>;

package/dist/typed-event/typed-event.js

@@ -1,50 +0,0 @@
-/**
- * A custom event with strict types for details and the event's `type` property.
- *
- * @category Internal
- */
-export class TypedEvent extends CustomEvent {
-    _type = '';
-    get type() {
-        return this._type;
-    }
-    constructor(type, value) {
-        super(typeof type === 'string' ? type : type.type, {
-            detail: value,
-            bubbles: true,
-            composed: true,
-        });
-    }
-}
-/**
- * Define a stand-alone typed event that can be emitted and listened to inside of HTML templates.
- *
- * Make sure to use currying and call this function twice! (This is required by TypeScript's type
- * parameter inference system.)
- *
- * @category Element Definition
- * @example
- *
- * ```ts
- * import {defineTypedEvent} from 'element-vir';
- *
- * const myCustomEvent = defineTypedEvent<number>()('my-custom-event');
- *
- * const myCustomEvent2 = defineTypedEvent<// the event's `.detail` type
- * number>()(
- *     // the event's `.type` string
- *     'my-custom-event2',
- * );
- * ```
- */
-export function defineTypedEvent() {
-    return (eventType) => {
-        return class extends TypedEvent {
-            static type = eventType;
-            _type = eventType;
-            constructor(value) {
-                super(eventType, value);
-            }
-        };
-    };
-}