@rxdi/lit-html 0.7.157 → 0.7.158

package/dist/reactive-element/css-tag.js

@@ -1,125 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCompatibleStyle = exports.adoptStyles = exports.css = exports.unsafeCSS = exports.CSSResult = exports.supportsAdoptingStyleSheets = void 0;
-/**
- * Whether the current browser supports `adoptedStyleSheets`.
- */
-exports.supportsAdoptingStyleSheets = window.ShadowRoot &&
-    (window.ShadyCSS === undefined || window.ShadyCSS.nativeShadow) &&
-    'adoptedStyleSheets' in Document.prototype &&
-    'replace' in CSSStyleSheet.prototype;
-const constructionToken = Symbol();
-const styleSheetCache = new Map();
-/**
- * A container for a string of CSS text, that may be used to create a CSSStyleSheet.
- *
- * CSSResult is the return value of `css`-tagged template literals and
- * `unsafeCSS()`. In order to ensure that CSSResults are only created via the
- * `css` tag and `unsafeCSS()`, CSSResult cannot be constructed directly.
- */
-class CSSResult {
-    constructor(cssText, safeToken) {
-        // This property needs to remain unminified.
-        this['_$cssResult$'] = true;
-        if (safeToken !== constructionToken) {
-            throw new Error('CSSResult is not constructable. Use `unsafeCSS` or `css` instead.');
-        }
-        this.cssText = cssText;
-    }
-    // Note, this is a getter so that it's lazy. In practice, this means
-    // stylesheets are not created until the first element instance is made.
-    get styleSheet() {
-        // Note, if `supportsAdoptingStyleSheets` is true then we assume
-        // CSSStyleSheet is constructable.
-        let styleSheet = styleSheetCache.get(this.cssText);
-        if (exports.supportsAdoptingStyleSheets && styleSheet === undefined) {
-            styleSheetCache.set(this.cssText, (styleSheet = new CSSStyleSheet()));
-            styleSheet.replaceSync(this.cssText);
-        }
-        return styleSheet;
-    }
-    toString() {
-        return this.cssText;
-    }
-}
-exports.CSSResult = CSSResult;
-const textFromCSSResult = (value) => {
-    // This property needs to remain unminified.
-    if (value['_$cssResult$'] === true) {
-        return value.cssText;
-    }
-    else if (typeof value === 'number') {
-        return value;
-    }
-    else {
-        throw new Error(`Value passed to 'css' function must be a 'css' function result: ` +
-            `${value}. Use 'unsafeCSS' to pass non-literal values, but take care ` +
-            `to ensure page security.`);
-    }
-};
-/**
- * Wrap a value for interpolation in a [[`css`]] tagged template literal.
- *
- * This is unsafe because untrusted CSS text can be used to phone home
- * or exfiltrate data to an attacker controlled site. Take care to only use
- * this with trusted input.
- */
-const unsafeCSS = (value) => new CSSResult(typeof value === 'string' ? value : String(value), constructionToken);
-exports.unsafeCSS = unsafeCSS;
-/**
- * A template literal tag which can be used with LitElement's
- * [[LitElement.styles | `styles`]] property to set element styles.
- *
- * For security reasons, only literal string values and number may be used in
- * embedded expressions. To incorporate non-literal values [[`unsafeCSS`]] may
- * be used inside an expression.
- */
-const css = (strings, ...values) => {
-    const cssText = strings.length === 1
-        ? strings[0]
-        : values.reduce((acc, v, idx) => acc + textFromCSSResult(v) + strings[idx + 1], strings[0]);
-    return new CSSResult(cssText, constructionToken);
-};
-exports.css = css;
-/**
- * Applies the given styles to a `shadowRoot`. When Shadow DOM is
- * available but `adoptedStyleSheets` is not, styles are appended to the
- * `shadowRoot` to [mimic spec behavior](https://wicg.github.io/construct-stylesheets/#using-constructed-stylesheets).
- * Note, when shimming is used, any styles that are subsequently placed into
- * the shadowRoot should be placed *before* any shimmed adopted styles. This
- * will match spec behavior that gives adopted sheets precedence over styles in
- * shadowRoot.
- */
-const adoptStyles = (renderRoot, styles) => {
-    if (exports.supportsAdoptingStyleSheets) {
-        renderRoot.adoptedStyleSheets = styles.map((s) => s instanceof CSSStyleSheet ? s : s.styleSheet);
-    }
-    else {
-        styles.forEach((s) => {
-            const style = document.createElement('style');
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const nonce = window['litNonce'];
-            if (nonce !== undefined) {
-                style.setAttribute('nonce', nonce);
-            }
-            style.textContent = s.cssText;
-            renderRoot.appendChild(style);
-        });
-    }
-};
-exports.adoptStyles = adoptStyles;
-const cssResultFromStyleSheet = (sheet) => {
-    let cssText = '';
-    for (const rule of sheet.cssRules) {
-        cssText += rule.cssText;
-    }
-    return (0, exports.unsafeCSS)(cssText);
-};
-exports.getCompatibleStyle = exports.supportsAdoptingStyleSheets
-    ? (s) => s
-    : (s) => s instanceof CSSStyleSheet ? cssResultFromStyleSheet(s) : s;

package/dist/reactive-element/decorators/base.d.ts

@@ -1,47 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ReactiveElement } from '../reactive-element';
-export declare type Constructor<T> = {
-    new (...args: any[]): T;
-};
-export interface ClassDescriptor {
-    kind: 'class';
-    elements: ClassElement[];
-    finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;
-}
-export interface ClassElement {
-    kind: 'field' | 'method';
-    key: PropertyKey;
-    placement: 'static' | 'prototype' | 'own';
-    initializer?: Function;
-    extras?: ClassElement[];
-    finisher?: <T>(clazz: Constructor<T>) => void | Constructor<T>;
-    descriptor?: PropertyDescriptor;
-}
-export declare const legacyPrototypeMethod: (descriptor: PropertyDescriptor, proto: Object, name: PropertyKey) => void;
-export declare const standardPrototypeMethod: (descriptor: PropertyDescriptor, element: ClassElement) => {
-    kind: string;
-    placement: string;
-    key: PropertyKey;
-    descriptor: PropertyDescriptor;
-};
-/**
- * Helper for decorating a property that is compatible with both TypeScript
- * and Babel decorators. The optional `finisher` can be used to perform work on
- * the class. The optional `descriptor` should return a PropertyDescriptor
- * to install for the given property.
- *
- * @param finisher {function} Optional finisher method; receives the element
- * constructor and property key as arguments and has no return value.
- * @param descriptor {function} Optional descriptor method; receives the
- * property key as an argument and returns a property descriptor to define for
- * the given property.
- * @returns {ClassElement|void}
- */
-export declare const decorateProperty: ({ finisher, descriptor, }: {
-    finisher?: (ctor: typeof ReactiveElement, property: PropertyKey) => void;
-    descriptor?: (property: PropertyKey) => PropertyDescriptor;
-}) => (protoOrDescriptor: ReactiveElement | ClassElement, name?: PropertyKey) => void | any;

package/dist/reactive-element/decorators/base.js

@@ -1,70 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateProperty = exports.standardPrototypeMethod = exports.legacyPrototypeMethod = void 0;
-const legacyPrototypeMethod = (descriptor, proto, name) => {
-    Object.defineProperty(proto, name, descriptor);
-};
-exports.legacyPrototypeMethod = legacyPrototypeMethod;
-const standardPrototypeMethod = (descriptor, element) => ({
-    kind: 'method',
-    placement: 'prototype',
-    key: element.key,
-    descriptor,
-});
-exports.standardPrototypeMethod = standardPrototypeMethod;
-/**
- * Helper for decorating a property that is compatible with both TypeScript
- * and Babel decorators. The optional `finisher` can be used to perform work on
- * the class. The optional `descriptor` should return a PropertyDescriptor
- * to install for the given property.
- *
- * @param finisher {function} Optional finisher method; receives the element
- * constructor and property key as arguments and has no return value.
- * @param descriptor {function} Optional descriptor method; receives the
- * property key as an argument and returns a property descriptor to define for
- * the given property.
- * @returns {ClassElement|void}
- */
-const decorateProperty = ({ finisher, descriptor, }) => (protoOrDescriptor, name
-// Note TypeScript requires the return type to be `void|any`
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) => {
-    var _a;
-    // TypeScript / Babel legacy mode
-    if (name !== undefined) {
-        const ctor = protoOrDescriptor
-            .constructor;
-        if (descriptor !== undefined) {
-            Object.defineProperty(protoOrDescriptor, name, descriptor(name));
-        }
-        finisher === null || finisher === void 0 ? void 0 : finisher(ctor, name);
-        // Babel standard mode
-    }
-    else {
-        // Note, the @property decorator saves `key` as `originalKey`
-        // so try to use it here.
-        const key = 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (_a = protoOrDescriptor.originalKey) !== null && _a !== void 0 ? _a : protoOrDescriptor.key;
-        const info = descriptor != undefined
-            ? {
-                kind: 'method',
-                placement: 'prototype',
-                key,
-                descriptor: descriptor(protoOrDescriptor.key),
-            }
-            : Object.assign(Object.assign({}, protoOrDescriptor), { key });
-        if (finisher != undefined) {
-            info.finisher = function (ctor) {
-                finisher(ctor, key);
-            };
-        }
-        return info;
-    }
-};
-exports.decorateProperty = decorateProperty;

package/dist/reactive-element/decorators/custom-element.d.ts

@@ -1,26 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ClassDescriptor } from './base';
-/**
- * Allow for custom element classes with private constructors
- */
-declare type CustomElementClass = Omit<typeof HTMLElement, 'new'>;
-/**
- * Class decorator factory that defines the decorated class as a custom element.
- *
- * ```js
- * @customElement('my-element')
- * class MyElement extends LitElement {
- *   render() {
- *     return html``;
- *   }
- * }
- * ```
- * @category Decorator
- * @param tagName The tag name of the custom element to define.
- */
-export declare const customElement: (tagName: string) => (classOrDescriptor: CustomElementClass | ClassDescriptor) => any;
-export {};

package/dist/reactive-element/decorators/custom-element.js

@@ -1,47 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.customElement = void 0;
-const legacyCustomElement = (tagName, clazz) => {
-    window.customElements.define(tagName, clazz);
-    // Cast as any because TS doesn't recognize the return type as being a
-    // subtype of the decorated class when clazz is typed as
-    // `Constructor<HTMLElement>` for some reason.
-    // `Constructor<HTMLElement>` is helpful to make sure the decorator is
-    // applied to elements however.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return clazz;
-};
-const standardCustomElement = (tagName, descriptor) => {
-    const { kind, elements } = descriptor;
-    return {
-        kind,
-        elements,
-        // This callback is called once the class is otherwise fully defined
-        finisher(clazz) {
-            window.customElements.define(tagName, clazz);
-        },
-    };
-};
-/**
- * Class decorator factory that defines the decorated class as a custom element.
- *
- * ```js
- * @customElement('my-element')
- * class MyElement extends LitElement {
- *   render() {
- *     return html``;
- *   }
- * }
- * ```
- * @category Decorator
- * @param tagName The tag name of the custom element to define.
- */
-const customElement = (tagName) => (classOrDescriptor) => typeof classOrDescriptor === 'function'
-    ? legacyCustomElement(tagName, classOrDescriptor)
-    : standardCustomElement(tagName, classOrDescriptor);
-exports.customElement = customElement;

package/dist/reactive-element/decorators/event-options.d.ts

@@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ReactiveElement } from '../reactive-element';
-/**
- * Adds event listener options to a method used as an event listener in a
- * lit-html template.
- *
- * @param options An object that specifies event listener options as accepted by
- * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.
- *
- * Current browsers support the `capture`, `passive`, and `once` options. See:
- * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters
- *
- * ```ts
- * class MyElement {
- *   clicked = false;
- *
- *   render() {
- *     return html`
- *       <div @click=${this._onClick}`>
- *         <button></button>
- *       </div>
- *     `;
- *   }
- *
- *   @eventOptions({capture: true})
- *   _onClick(e) {
- *     this.clicked = true;
- *   }
- * }
- * ```
- * @category Decorator
- */
-export declare function eventOptions(options: AddEventListenerOptions): (protoOrDescriptor: ReactiveElement | import("./base").ClassElement, name?: PropertyKey) => any;

package/dist/reactive-element/decorators/event-options.js

@@ -1,47 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventOptions = void 0;
-const base_1 = require("./base");
-/**
- * Adds event listener options to a method used as an event listener in a
- * lit-html template.
- *
- * @param options An object that specifies event listener options as accepted by
- * `EventTarget#addEventListener` and `EventTarget#removeEventListener`.
- *
- * Current browsers support the `capture`, `passive`, and `once` options. See:
- * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Parameters
- *
- * ```ts
- * class MyElement {
- *   clicked = false;
- *
- *   render() {
- *     return html`
- *       <div @click=${this._onClick}`>
- *         <button></button>
- *       </div>
- *     `;
- *   }
- *
- *   @eventOptions({capture: true})
- *   _onClick(e) {
- *     this.clicked = true;
- *   }
- * }
- * ```
- * @category Decorator
- */
-function eventOptions(options) {
-    return (0, base_1.decorateProperty)({
-        finisher: (ctor, name) => {
-            Object.assign(ctor.prototype[name], options);
-        },
-    });
-}
-exports.eventOptions = eventOptions;

package/dist/reactive-element/decorators/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-export * from './base';
-export * from './custom-element';
-export * from './property';
-export * from './state';
-export * from './event-options';
-export * from './query';
-export * from './query-all';
-export * from './query-async';
-export * from './query-assigned-nodes';

package/dist/reactive-element/decorators/index.js

@@ -1,32 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/*
- * IMPORTANT: For compatibility with tsickle and the Closure JS compiler, all
- * property decorators (but not class decorators) in this file that have
- * an @ExportDecoratedItems annotation must be defined as a regular function,
- * not an arrow function.
- */
-__exportStar(require("./base"), exports);
-__exportStar(require("./custom-element"), exports);
-__exportStar(require("./property"), exports);
-__exportStar(require("./state"), exports);
-__exportStar(require("./event-options"), exports);
-__exportStar(require("./query"), exports);
-__exportStar(require("./query-all"), exports);
-__exportStar(require("./query-async"), exports);
-__exportStar(require("./query-assigned-nodes"), exports);

package/dist/reactive-element/decorators/property.d.ts

@@ -1,40 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { PropertyDeclaration } from '../reactive-element';
-import { ClassElement } from './base';
-/**
- * A property decorator which creates a reactive property that reflects a
- * corresponding attribute value. When a decorated property is set
- * the element will update and render. A [[`PropertyDeclaration`]] may
- * optionally be supplied to configure property features.
- *
- * This decorator should only be used for public fields. As public fields,
- * properties should be considered as primarily settable by element users,
- * either via attribute or the property itself.
- *
- * Generally, properties that are changed by the element should be private or
- * protected fields and should use the [[`state`]] decorator.
- *
- * However, sometimes element code does need to set a public property. This
- * should typically only be done in response to user interaction, and an event
- * should be fired informing the user; for example, a checkbox sets its
- * `checked` property when clicked and fires a `changed` event. Mutating public
- * properties should typically not be done for non-primitive (object or array)
- * properties. In other cases when an element needs to manage state, a private
- * property decorated via the [[`state`]] decorator should be used. When needed,
- * state properties can be initialized via public properties to facilitate
- * complex interactions.
- *
- * ```ts
- * class MyElement {
- *   @property({ type: Boolean })
- *   clicked = false;
- * }
- * ```
- * @category Decorator
- * @ExportDecoratedItems
- */
-export declare function property(options?: PropertyDeclaration): (protoOrDescriptor: Object | ClassElement, name?: PropertyKey) => any;

package/dist/reactive-element/decorators/property.js

@@ -1,92 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.property = void 0;
-const standardProperty = (options, element) => {
-    // When decorating an accessor, pass it through and add property metadata.
-    // Note, the `hasOwnProperty` check in `createProperty` ensures we don't
-    // stomp over the user's accessor.
-    if (element.kind === 'method' &&
-        element.descriptor &&
-        !('value' in element.descriptor)) {
-        return Object.assign(Object.assign({}, element), { finisher(clazz) {
-                clazz.createProperty(element.key, options);
-            } });
-    }
-    else {
-        // createProperty() takes care of defining the property, but we still
-        // must return some kind of descriptor, so return a descriptor for an
-        // unused prototype field. The finisher calls createProperty().
-        return {
-            kind: 'field',
-            key: Symbol(),
-            placement: 'own',
-            descriptor: {},
-            // store the original key so subsequent decorators have access to it.
-            originalKey: element.key,
-            // When @babel/plugin-proposal-decorators implements initializers,
-            // do this instead of the initializer below. See:
-            // https://github.com/babel/babel/issues/9260 extras: [
-            //   {
-            //     kind: 'initializer',
-            //     placement: 'own',
-            //     initializer: descriptor.initializer,
-            //   }
-            // ],
-            initializer() {
-                if (typeof element.initializer === 'function') {
-                    this[element.key] = element.initializer.call(this);
-                }
-            },
-            finisher(clazz) {
-                clazz.createProperty(element.key, options);
-            },
-        };
-    }
-};
-const legacyProperty = (options, proto, name) => {
-    proto.constructor.createProperty(name, options);
-};
-/**
- * A property decorator which creates a reactive property that reflects a
- * corresponding attribute value. When a decorated property is set
- * the element will update and render. A [[`PropertyDeclaration`]] may
- * optionally be supplied to configure property features.
- *
- * This decorator should only be used for public fields. As public fields,
- * properties should be considered as primarily settable by element users,
- * either via attribute or the property itself.
- *
- * Generally, properties that are changed by the element should be private or
- * protected fields and should use the [[`state`]] decorator.
- *
- * However, sometimes element code does need to set a public property. This
- * should typically only be done in response to user interaction, and an event
- * should be fired informing the user; for example, a checkbox sets its
- * `checked` property when clicked and fires a `changed` event. Mutating public
- * properties should typically not be done for non-primitive (object or array)
- * properties. In other cases when an element needs to manage state, a private
- * property decorated via the [[`state`]] decorator should be used. When needed,
- * state properties can be initialized via public properties to facilitate
- * complex interactions.
- *
- * ```ts
- * class MyElement {
- *   @property({ type: Boolean })
- *   clicked = false;
- * }
- * ```
- * @category Decorator
- * @ExportDecoratedItems
- */
-function property(options) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (protoOrDescriptor, name) => name !== undefined
-        ? legacyProperty(options, protoOrDescriptor, name)
-        : standardProperty(options, protoOrDescriptor);
-}
-exports.property = property;

package/dist/reactive-element/decorators/query-all.d.ts

@@ -1,31 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-import { ReactiveElement } from '../reactive-element';
-/**
- * A property decorator that converts a class property into a getter
- * that executes a querySelectorAll on the element's renderRoot.
- *
- * @param selector A DOMString containing one or more selectors to match.
- *
- * See:
- * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll
- *
- * ```ts
- * class MyElement {
- *   @queryAll('div')
- *   divs;
- *
- *   render() {
- *     return html`
- *       <div id="first"></div>
- *       <div id="second"></div>
- *     `;
- *   }
- * }
- * ```
- * @category Decorator
- */
-export declare function queryAll(selector: string): (protoOrDescriptor: ReactiveElement | import("./base").ClassElement, name?: PropertyKey) => any;

package/dist/reactive-element/decorators/query-all.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryAll = void 0;
-const base_1 = require("./base");
-/**
- * A property decorator that converts a class property into a getter
- * that executes a querySelectorAll on the element's renderRoot.
- *
- * @param selector A DOMString containing one or more selectors to match.
- *
- * See:
- * https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll
- *
- * ```ts
- * class MyElement {
- *   @queryAll('div')
- *   divs;
- *
- *   render() {
- *     return html`
- *       <div id="first"></div>
- *       <div id="second"></div>
- *     `;
- *   }
- * }
- * ```
- * @category Decorator
- */
-function queryAll(selector) {
-    return (0, base_1.decorateProperty)({
-        descriptor: (_name) => ({
-            get() {
-                var _a, _b;
-                return (_b = (_a = this.renderRoot) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector)) !== null && _b !== void 0 ? _b : [];
-            },
-            enumerable: true,
-            configurable: true,
-        }),
-    });
-}
-exports.queryAll = queryAll;