element-vir 6.3.3 → 7.0.0

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

@@ -1,4 +0,0 @@
-export type ConstructorWithTagName = Function & {
-    tagName: string;
-};
-export declare function hasStaticTagName(value: unknown): value is ConstructorWithTagName;

package/dist/template-transforms/has-static-tag-name.js

@@ -1,6 +0,0 @@
-export function hasStaticTagName(value) {
-    return (typeof value === 'function' &&
-        value.hasOwnProperty('tagName') &&
-        typeof value.tagName === 'string' &&
-        value.tagName.includes('-'));
-}

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

@@ -1,6 +0,0 @@
-import { TemplateTransform } from './transform-template';
-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 { typedHasProperties } from '@augment-vir/common';
-import { DeclarativeElementMarkerSymbol } from '../declarative-element-marker-symbol';
-function extractElementKeys(values) {
-    return values.filter((value) => {
-        return (typedHasProperties(value, [
-            'tagName',
-            DeclarativeElementMarkerSymbol,
-        ]) &&
-            !!value.tagName &&
-            !!value[DeclarativeElementMarkerSymbol]);
-    });
-}
-/**
- * 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) {
-    var _a;
-    const elementKeys = extractElementKeys(values);
-    const nestedValue = getNestedValues(transformedTemplateStrings, [
-        templateStringsKey,
-        ...elementKeys,
-    ]);
-    return (_a = nestedValue.value) === null || _a === void 0 ? void 0 : _a.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) {
-    var _a;
-    const { currentTemplateAndNested, currentKey, reason } = getCurrentKeyAndValue(map, keys, index);
-    if (!currentKey) {
-        return { result: false, reason };
-    }
-    const nestedAndTemplate = currentTemplateAndNested !== null && currentTemplateAndNested !== void 0 ? 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 = (_a = nestedAndTemplate.nested) !== null && _a !== void 0 ? _a : new WeakMap();
-    if (!nestedAndTemplate.nested) {
-        nestedAndTemplate.nested = nestedWeakMap;
-    }
-    return setNestedValues(nestedWeakMap, keys, valueToSet, index + 1);
-}

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

@@ -1,16 +0,0 @@
-export type TemplateTransform = {
-    templateStrings: TemplateStringsArray;
-    valueIndexDeletions: number[];
-};
-export type ValueTransform = (value: unknown) => unknown;
-export type CheckAndTransform<T> = {
-    check: (lastNewString: string, currentLitString: string, currentValue: unknown) => currentValue is T;
-    transform: (value: T) => unknown;
-    name: string;
-};
-export declare function makeCheckTransform<T>(name: string, check: (lastNewString: string, currentLitString: string, currentValue: unknown) => currentValue is T, transform: (value: T) => unknown): CheckAndTransform<T>;
-export declare function getTransformedTemplate<PossibleValues>(templateStringsKey: TemplateStringsArray, values: PossibleValues[], fallbackTransform: () => TemplateTransform): {
-    strings: TemplateStringsArray;
-    values: PossibleValues[];
-};
-export declare function transformTemplate<TransformsGeneric extends CheckAndTransform<any>[], PossibleValues>(inputTemplateStrings: TemplateStringsArray, inputValues: PossibleValues[], checksAndTransforms: TransformsGeneric, assertValidString?: (templateStringPart: string) => void): TemplateTransform;

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

@@ -1,87 +0,0 @@
-import { typedHasProperties } from '@augment-vir/common';
-import { filterOutArrayIndexes } from '../augments/array';
-import { DeclarativeElementMarkerSymbol } from '../declarative-element-marker-symbol';
-import { getAlreadyMappedTemplate, setMappedTemplate } from './nested-mapped-templates';
-export function makeCheckTransform(name, check, transform) {
-    return {
-        name,
-        check,
-        transform,
-    };
-}
-/**
- * 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();
-function extractElementValues(values) {
-    return values.filter((value) => {
-        return (typedHasProperties(value, [
-            'tagName',
-            DeclarativeElementMarkerSymbol,
-        ]) &&
-            !!value.tagName &&
-            !!value[DeclarativeElementMarkerSymbol]);
-    });
-}
-export function getTransformedTemplate(templateStringsKey, values, fallbackTransform) {
-    const alreadyTransformedTemplateStrings = getAlreadyMappedTemplate(templateStringsKey, values);
-    const templateTransform = alreadyTransformedTemplateStrings !== null && alreadyTransformedTemplateStrings !== void 0 ? alreadyTransformedTemplateStrings : fallbackTransform();
-    if (!alreadyTransformedTemplateStrings) {
-        const result = setMappedTemplate(templateStringsKey, values, templateTransform);
-        if (!result.result) {
-            throw new Error(`Failed to set template transform: ${result.reason}`);
-        }
-        else {
-            transformedTemplateStrings.set(templateStringsKey, templateTransform);
-        }
-    }
-    const transformedValuesArray = filterOutArrayIndexes(values, templateTransform.valueIndexDeletions);
-    return { strings: templateTransform.templateStrings, values: transformedValuesArray };
-}
-export function transformTemplate(inputTemplateStrings, inputValues, checksAndTransforms, assertValidString) {
-    const newStrings = [];
-    const newRaws = [];
-    const valueDeletions = [];
-    inputTemplateStrings.forEach((currentTemplateString, index) => {
-        var _a;
-        const lastNewStringsIndex = newStrings.length - 1;
-        const lastNewString = newStrings[lastNewStringsIndex];
-        const currentValueIndex = index - 1;
-        const currentValue = inputValues[currentValueIndex];
-        let validTransform;
-        assertValidString && assertValidString(currentTemplateString);
-        if (typeof lastNewString === 'string') {
-            validTransform = (_a = checksAndTransforms.find((checkAndTransform) => {
-                return checkAndTransform.check(lastNewString, currentTemplateString, currentValue);
-            })) === null || _a === void 0 ? void 0 : _a.transform;
-            if (validTransform) {
-                newStrings[lastNewStringsIndex] =
-                    lastNewString + validTransform(currentValue) + currentTemplateString;
-                valueDeletions.push(currentValueIndex);
-            }
-        }
-        if (!validTransform) {
-            newStrings.push(currentTemplateString);
-        }
-        const currentRawLitString = inputTemplateStrings.raw[index];
-        if (validTransform) {
-            newRaws[lastNewStringsIndex] =
-                newRaws[lastNewStringsIndex] + validTransform(currentValue) + currentRawLitString;
-        }
-        else {
-            newRaws.push(currentRawLitString);
-        }
-    });
-    const newTemplateStrings = Object.assign([], newStrings, {
-        raw: newRaws,
-    });
-    return {
-        templateStrings: newTemplateStrings,
-        valueIndexDeletions: valueDeletions,
-    };
-}

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

@@ -1,7 +0,0 @@
-import { CSSResultGroup } from 'lit';
-import { DeclarativeElementDefinition } from '../../declarative-element/declarative-element';
-export type CssTemplateTransform = {
-    templateStrings: TemplateStringsArray;
-    valueIndexDeletions: number[];
-};
-export declare function transformCssTemplate(inputTemplateStrings: TemplateStringsArray, inputValues: (number | CSSResultGroup | DeclarativeElementDefinition)[]): CssTemplateTransform;

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

@@ -1,12 +0,0 @@
-import { hasStaticTagName } from '../has-static-tag-name';
-import { makeCheckTransform, transformTemplate } from '../transform-template';
-const cssChecksAndTransforms = [
-    makeCheckTransform('tag name css selector interpolation', (lastNewString, currentLitString, currentValue) => {
-        return hasStaticTagName(currentValue);
-    }, (input) => 
-    // cast is safe because the check method above verifies that this value is a VirElement
-    input.tagName),
-];
-export function transformCssTemplate(inputTemplateStrings, inputValues) {
-    return transformTemplate(inputTemplateStrings, inputValues, cssChecksAndTransforms);
-}

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

@@ -1,3 +0,0 @@
-import { CSSResult, CSSResultGroup } from 'lit';
-import { DeclarativeElementDefinition } from '../../declarative-element/declarative-element';
-export declare function css(inputTemplateStrings: TemplateStringsArray, ...inputValues: (number | CSSResultGroup | DeclarativeElementDefinition)[]): CSSResult;

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

@@ -1,12 +0,0 @@
-import { css as litCss } from 'lit';
-import { getTransformedTemplate } from '../transform-template';
-import { transformCssTemplate } from './css-transform';
-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-transform.d.ts

@@ -1,3 +0,0 @@
-import { HTMLTemplateResult } from 'lit';
-import { TemplateTransform } from '../transform-template';
-export declare function transformHtmlTemplate(litTemplate: HTMLTemplateResult): TemplateTransform;

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

@@ -1,44 +0,0 @@
-import { collapseWhiteSpace, safeMatch } from '@augment-vir/common';
-import { declarativeElementRequired } from '../../require-declarative-element';
-import { hasStaticTagName } from '../has-static-tag-name';
-import { makeCheckTransform, transformTemplate, } from '../transform-template';
-const htmlChecksAndTransforms = [
-    makeCheckTransform('tag name interpolation', (lastNewString, currentLitString, currentValue) => {
-        const shouldHaveTagNameHere = (lastNewString.trim().endsWith('<') && !!currentLitString.match(/^[\s\n>]/)) ||
-            ((lastNewString === null || lastNewString === void 0 ? void 0 : lastNewString.trim().endsWith('</')) && currentLitString.trim().startsWith('>'));
-        const staticTagName = hasStaticTagName(currentValue);
-        if (shouldHaveTagNameHere && !staticTagName) {
-            console.error({
-                lastNewString,
-                currentLitString,
-                currentValue,
-            });
-            throw new Error(`Got interpolated tag name but it wasn't of type VirElement: ${currentValue.prototype.constructor.name}`);
-        }
-        return shouldHaveTagNameHere && staticTagName;
-    }, (input) => 
-    // cast is safe because the check method above verifies that this value is a VirElement
-    input.tagName),
-];
-function extractCustomElementTags(input) {
-    const tagNameMatches = safeMatch(input, /<\/[\s\n]*[^\s\n><]+[\s\n]*>/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, htmlChecksAndTransforms, stringValidator);
-}

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

@@ -1,3 +0,0 @@
-import { HTMLTemplateResult } from 'lit';
-/** Enables interpolation of DeclarativeElement tag names */
-export declare function html(inputTemplateStrings: TemplateStringsArray, ...inputValues: unknown[]): HTMLTemplateResult;

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

@@ -1,16 +0,0 @@
-import { html as litHtml } from 'lit';
-import { getTransformedTemplate } from '../transform-template';
-import { transformHtmlTemplate } from './html-transform';
-/** Enables interpolation of DeclarativeElement tag names */
-export function html(inputTemplateStrings, ...inputValues) {
-    const litTemplate = litHtml(inputTemplateStrings, ...inputValues);
-    const transformedTemplate = getTransformedTemplate(inputTemplateStrings, inputValues, () => {
-        return transformHtmlTemplate(litTemplate);
-    });
-    const htmlTemplate = {
-        ...litTemplate,
-        strings: transformedTemplate.strings,
-        values: transformedTemplate.values,
-    };
-    return htmlTemplate;
-}

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

@@ -1,19 +0,0 @@
-import { NonEmptyString } from '../augments/type';
-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);
-}
-export type DefinedTypedEventNameDefinition<EventDetailGeneric> = <EventTypeNameGeneric extends string>(eventType: NonEmptyString<EventTypeNameGeneric>) => DefinedTypedEvent<EventTypeNameGeneric, EventDetailGeneric>;
-export type DefinedTypedEvent<EventTypeNameGeneric extends string, EventDetailGeneric> = (new (eventValue: EventDetailGeneric) => TypedEvent<EventTypeNameGeneric, EventDetailGeneric>) & {
-    type: EventTypeNameGeneric;
-};
-/**
- * Defined a typed event. Make sure to use currying and call this function twice! Typescript's
- * generic restrictions require this setup to get the types right without excessive verbosity.
- *
- * Example: const myCustomEvent = defineTypedEvent<number>()('my-custom-event')
- */
-export declare function defineTypedEvent<EventDetailGeneric>(): <EventTypeNameGeneric extends string>(eventType: NonEmptyString<EventTypeNameGeneric>) => DefinedTypedEvent<EventTypeNameGeneric, EventDetailGeneric>;

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

@@ -1,32 +0,0 @@
-export class TypedEvent extends CustomEvent {
-    get type() {
-        return this._type;
-    }
-    constructor(type, value) {
-        super(typeof type === 'string' ? type : type.type, {
-            detail: value,
-            bubbles: true,
-            composed: true,
-        });
-        this._type = '';
-    }
-}
-/**
- * Defined a typed event. Make sure to use currying and call this function twice! Typescript's
- * generic restrictions require this setup to get the types right without excessive verbosity.
- *
- * Example: const myCustomEvent = defineTypedEvent<number>()('my-custom-event')
- */
-export function defineTypedEvent() {
-    return (eventType) => {
-        var _a;
-        return _a = class extends TypedEvent {
-                constructor(value) {
-                    super(eventType, value);
-                    this._type = eventType;
-                }
-            },
-            _a.type = eventType,
-            _a;
-    };
-}