@rxdi/lit-html 0.7.157 → 0.7.159

package/dist/lit-element/lit-element.js

@@ -1,258 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var _a, _b, _c, _d;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._$LE = exports.LitElement = exports.UpdatingElement = void 0;
-/**
- * The main LitElement module, which defines the [[`LitElement`]] base class and
- * related APIs.
- *
- *  LitElement components can define a template and a set of observed
- * properties. Changing an observed property triggers a re-render of the
- * element.
- *
- *  Import [[`LitElement`]] and [[`html`]] from this module to create a
- * component:
- *
- *  ```js
- * import {LitElement, html} from 'lit-element';
- *
- * class MyElement extends LitElement {
- *
- *   // Declare observed properties
- *   static get properties() {
- *     return {
- *       adjective: {}
- *     }
- *   }
- *
- *   constructor() {
- *     this.adjective = 'awesome';
- *   }
- *
- *   // Define the element's template
- *   render() {
- *     return html`<p>your ${adjective} template here</p>`;
- *   }
- * }
- *
- * customElements.define('my-element', MyElement);
- * ```
- *
- * `LitElement` extends [[`ReactiveElement`]] and adds lit-html templating.
- * The `ReactiveElement` class is provided for users that want to build
- * their own custom element base classes that don't use lit-html.
- *
- * @packageDocumentation
- */
-const reactive_element_1 = require("../reactive-element");
-const lit_html_1 = require("../lit-html/lit-html");
-// For backwards compatibility export ReactiveElement as UpdatingElement. Note,
-// IE transpilation requires exporting like this.
-exports.UpdatingElement = reactive_element_1.ReactiveElement;
-const DEV_MODE = true;
-let issueWarning;
-if (DEV_MODE) {
-    // Ensure warnings are issued only 1x, even if multiple versions of Lit
-    // are loaded.
-    const issuedWarnings = ((_a = globalThis.litIssuedWarnings) !== null && _a !== void 0 ? _a : (globalThis.litIssuedWarnings = new Set()));
-    // Issue a warning, if we haven't already.
-    issueWarning = (code, warning) => {
-        warning += ` See https://lit.dev/msg/${code} for more information.`;
-        if (!issuedWarnings.has(warning)) {
-            console.warn(warning);
-            issuedWarnings.add(warning);
-        }
-    };
-}
-/**
- * Base element class that manages element properties and attributes, and
- * renders a lit-html template.
- *
- * To define a component, subclass `LitElement` and implement a
- * `render` method to provide the component's template. Define properties
- * using the [[`properties`]] property or the [[`property`]] decorator.
- */
-class LitElement extends reactive_element_1.ReactiveElement {
-    constructor() {
-        super(...arguments);
-        /**
-         * @category rendering
-         */
-        this.renderOptions = { host: this };
-        this.__childPart = undefined;
-    }
-    /**
-     * @category rendering
-     */
-    createRenderRoot() {
-        var _a;
-        var _b;
-        const renderRoot = super.createRenderRoot();
-        // When adoptedStyleSheets are shimmed, they are inserted into the
-        // shadowRoot by createRenderRoot. Adjust the renderBefore node so that
-        // any styles in Lit content render before adoptedStyleSheets. This is
-        // important so that adoptedStyleSheets have precedence over styles in
-        // the shadowRoot.
-        (_a = (_b = this.renderOptions).renderBefore) !== null && _a !== void 0 ? _a : (_b.renderBefore = renderRoot.firstChild);
-        return renderRoot;
-    }
-    /**
-     * Updates the element. This method reflects property values to attributes
-     * and calls `render` to render DOM via lit-html. Setting properties inside
-     * this method will *not* trigger another update.
-     * @param changedProperties Map of changed properties with old values
-     * @category updates
-     */
-    update(changedProperties) {
-        // Setting properties in `render` should not trigger an update. Since
-        // updates are allowed after super.update, it's important to call `render`
-        // before that.
-        const value = this.render();
-        if (!this.hasUpdated) {
-            this.renderOptions.isConnected = this.isConnected;
-        }
-        super.update(changedProperties);
-        this.__childPart = (0, lit_html_1.render)(value, this.renderRoot, this.renderOptions);
-    }
-    /**
-     * Invoked when the component is added to the document's DOM.
-     *
-     * In `connectedCallback()` you should setup tasks that should only occur when
-     * the element is connected to the document. The most common of these is
-     * adding event listeners to nodes external to the element, like a keydown
-     * event handler added to the window.
-     *
-     * ```ts
-     * connectedCallback() {
-     *   super.connectedCallback();
-     *   addEventListener('keydown', this._handleKeydown);
-     * }
-     * ```
-     *
-     * Typically, anything done in `connectedCallback()` should be undone when the
-     * element is disconnected, in `disconnectedCallback()`.
-     *
-     * @category lifecycle
-     */
-    connectedCallback() {
-        var _a;
-        super.connectedCallback();
-        (_a = this.__childPart) === null || _a === void 0 ? void 0 : _a.setConnected(true);
-    }
-    /**
-     * Invoked when the component is removed from the document's DOM.
-     *
-     * This callback is the main signal to the element that it may no longer be
-     * used. `disconnectedCallback()` should ensure that nothing is holding a
-     * reference to the element (such as event listeners added to nodes external
-     * to the element), so that it is free to be garbage collected.
-     *
-     * ```ts
-     * disconnectedCallback() {
-     *   super.disconnectedCallback();
-     *   window.removeEventListener('keydown', this._handleKeydown);
-     * }
-     * ```
-     *
-     * An element may be re-connected after being disconnected.
-     *
-     * @category lifecycle
-     */
-    disconnectedCallback() {
-        var _a;
-        super.disconnectedCallback();
-        (_a = this.__childPart) === null || _a === void 0 ? void 0 : _a.setConnected(false);
-    }
-    /**
-     * Invoked on each update to perform rendering tasks. This method may return
-     * any value renderable by lit-html's `ChildPart` - typically a
-     * `TemplateResult`. Setting properties inside this method will *not* trigger
-     * the element to update.
-     * @category rendering
-     */
-    render() {
-        return lit_html_1.noChange;
-    }
-}
-exports.LitElement = LitElement;
-/**
- * Ensure this class is marked as `finalized` as an optimization ensuring
- * it will not needlessly try to `finalize`.
- *
- * Note this property name is a string to prevent breaking Closure JS Compiler
- * optimizations. See @lit/reactive-element for more information.
- */
-LitElement['finalized'] = true;
-// This property needs to remain unminified.
-LitElement['_$litElement$'] = true;
-// Install hydration if available
-(_b = globalThis.litElementHydrateSupport) === null || _b === void 0 ? void 0 : _b.call(globalThis, { LitElement });
-// Apply polyfills if available
-(_c = globalThis[`litElementPolyfillSupport${DEV_MODE ? `DevMode` : ``}`]) === null || _c === void 0 ? void 0 : _c.call(globalThis, {
-    LitElement,
-});
-// DEV mode warnings
-if (DEV_MODE) {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    // Note, for compatibility with closure compilation, this access
-    // needs to be as a string property index.
-    LitElement['finalize'] = function () {
-        const finalized = reactive_element_1.ReactiveElement.finalize.call(this);
-        if (!finalized) {
-            return false;
-        }
-        const warnRemovedOrRenamed = (obj, name, renamed = false) => {
-            if (obj.hasOwnProperty(name)) {
-                const ctorName = (typeof obj === 'function' ? obj : obj.constructor)
-                    .name;
-                issueWarning(renamed ? 'renamed-api' : 'removed-api', `\`${name}\` is implemented on class ${ctorName}. It ` +
-                    `has been ${renamed ? 'renamed' : 'removed'} ` +
-                    `in this version of LitElement.`);
-            }
-        };
-        warnRemovedOrRenamed(this, 'render');
-        warnRemovedOrRenamed(this, 'getStyles', true);
-        warnRemovedOrRenamed(this.prototype, 'adoptStyles');
-        return true;
-    };
-    /* eslint-enable @typescript-eslint/no-explicit-any */
-}
-/**
- * END USERS SHOULD NOT RELY ON THIS OBJECT.
- *
- * Private exports for use by other Lit packages, not intended for use by
- * external users.
- *
- * We currently do not make a mangled rollup build of the lit-ssr code. In order
- * to keep a number of (otherwise private) top-level exports  mangled in the
- * client side code, we export a _$LE object containing those members (or
- * helper methods for accessing private fields of those members), and then
- * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
- * client-side code is being used in `dev` mode or `prod` mode.
- *
- * This has a unique name, to disambiguate it from private exports in
- * lit-html, since this module re-exports all of lit-html.
- *
- * @private
- */
-exports._$LE = {
-    _$attributeToProperty: (el, name, value) => {
-        // eslint-disable-next-line
-        el._$attributeToProperty(name, value);
-    },
-    // eslint-disable-next-line
-    _$changedProperties: (el) => el._$changedProperties,
-};
-// IMPORTANT: do not change the property name or the assignment expression.
-// This line will be used in regexes to search for LitElement usage.
-// TODO(justinfagnani): inject version number at build time
-((_d = globalThis.litElementVersions) !== null && _d !== void 0 ? _d : (globalThis.litElementVersions = [])).push('3.0.0');
-if (DEV_MODE && globalThis.litElementVersions.length > 1) {
-    issueWarning('multiple-versions', `Multiple versions of Lit loaded. Loading multiple versions ` +
-        `is not recommended.`);
-}

package/dist/lit-element/polyfill-support.d.ts

@@ -1,24 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * LitElement patch to support browsers without native web components.
- *
- * This module should be used in addition to loading the web components
- * polyfills via @webcomponents/webcomponentjs. When using those polyfills
- * support for polyfilled Shadow DOM is automatic via the ShadyDOM polyfill, but
- * support for Shadow DOM like css scoping is opt-in. This module uses ShadyCSS
- * to scope styles defined via the `static styles` property and styles included
- * in the render method. There are some limitations to be aware of:
- * * only styles that are included in the first render of a component are scoped.
- * * In addition, support for the deprecated `@apply` feature of ShadyCSS is
- * only provided for styles included in the template and not styles provided
- * via the static styles property.
- * * Lit parts cannot be used in styles included in the template.
- *
- * @packageDocumentation
- */
-import '../reactive-element/polyfill-support';
-import '../lit-html/polyfill-support';

package/dist/lit-element/polyfill-support.js

@@ -1,58 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-var _a;
-var _b;
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * LitElement patch to support browsers without native web components.
- *
- * This module should be used in addition to loading the web components
- * polyfills via @webcomponents/webcomponentjs. When using those polyfills
- * support for polyfilled Shadow DOM is automatic via the ShadyDOM polyfill, but
- * support for Shadow DOM like css scoping is opt-in. This module uses ShadyCSS
- * to scope styles defined via the `static styles` property and styles included
- * in the render method. There are some limitations to be aware of:
- * * only styles that are included in the first render of a component are scoped.
- * * In addition, support for the deprecated `@apply` feature of ShadyCSS is
- * only provided for styles included in the template and not styles provided
- * via the static styles property.
- * * Lit parts cannot be used in styles included in the template.
- *
- * @packageDocumentation
- */
-require("../reactive-element/polyfill-support");
-require("../lit-html/polyfill-support");
-// Note, explicitly use `var` here so that this can be re-defined when
-// bundled.
-// eslint-disable-next-line no-var
-var DEV_MODE = true;
-(_a = globalThis[_b = `litElementPolyfillSupport${DEV_MODE ? `DevMode` : ``}`]) !== null && _a !== void 0 ? _a : (globalThis[_b] = ({ LitElement, }) => {
-    // polyfill-support is only needed if ShadyCSS or the ApplyShim is in use
-    // We test at the point of patching, which makes it safe to load
-    // webcomponentsjs and polyfill-support in either order
-    if (window.ShadyCSS === undefined ||
-        (window.ShadyCSS.nativeShadow && !window.ShadyCSS.ApplyShim)) {
-        return;
-    }
-    // console.log(
-    //   '%c Making LitElement compatible with ShadyDOM/CSS.',
-    //   'color: lightgreen; font-style: italic'
-    // );
-    LitElement._$handlesPrepareStyles = true;
-    /**
-     * Patch to apply adoptedStyleSheets via ShadyCSS
-     */
-    const litElementProto = LitElement.prototype;
-    const createRenderRoot = litElementProto.createRenderRoot;
-    litElementProto.createRenderRoot = function () {
-        // Pass the scope to render options so that it gets to lit-html for proper
-        // scoping via ShadyCSS. This is needed under Shady and also Shadow DOM,
-        // due to @apply.
-        this.renderOptions.scope = this.localName;
-        return createRenderRoot.call(this);
-    };
-});

package/dist/lit-element/private-ssr-support.d.ts

@@ -1,21 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * END USERS SHOULD NOT RELY ON THIS OBJECT.
- *
- * We currently do not make a mangled rollup build of the lit-ssr code. In order
- * to keep a number of (otherwise private) top-level exports  mangled in the
- * client side code, we export a _$LE object containing those members (or
- * helper methods for accessing private fields of those members), and then
- * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
- * client-side code is being used in `dev` mode or `prod` mode.
- *
- * @private
- */
-export declare const _$LE: {
-    attributeToProperty: (el: import("./lit-element").LitElement, name: string, value: string) => void;
-    changedProperties: (el: import("./lit-element").LitElement) => any;
-};

package/dist/lit-element/private-ssr-support.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._$LE = void 0;
-const lit_element_1 = require("./lit-element");
-/**
- * END USERS SHOULD NOT RELY ON THIS OBJECT.
- *
- * We currently do not make a mangled rollup build of the lit-ssr code. In order
- * to keep a number of (otherwise private) top-level exports  mangled in the
- * client side code, we export a _$LE object containing those members (or
- * helper methods for accessing private fields of those members), and then
- * re-export them for use in lit-ssr. This keeps lit-ssr agnostic to whether the
- * client-side code is being used in `dev` mode or `prod` mode.
- *
- * @private
- */
-exports._$LE = {
-    attributeToProperty: lit_element_1._$LE._$attributeToProperty,
-    changedProperties: lit_element_1._$LE._$changedProperties,
-};

package/dist/lit-html/async-directive.d.ts

@@ -1,170 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */
-/**
- * Overview:
- *
- * This module is designed to add support for an async `setValue` API and
- * `disconnected` callback to directives with the least impact on the core
- * runtime or payload when that feature is not used.
- *
- * The strategy is to introduce a `AsyncDirective` subclass of
- * `Directive` that climbs the "parent" tree in its constructor to note which
- * branches of lit-html's "logical tree" of data structures contain such
- * directives and thus need to be crawled when a subtree is being cleared (or
- * manually disconnected) in order to run the `disconnected` callback.
- *
- * The "nodes" of the logical tree include Parts, TemplateInstances (for when a
- * TemplateResult is committed to a value of a ChildPart), and Directives; these
- * all implement a common interface called `DisconnectableChild`. Each has a
- * `_$parent` reference which is set during construction in the core code, and a
- * `_$disconnectableChildren` field which is initially undefined.
- *
- * The sparse tree created by means of the `AsyncDirective` constructor
- * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set
- * on each parent that includes each child that contains a
- * `AsyncDirective` directly or transitively via its children. In order to
- * notify connection state changes and disconnect (or reconnect) a tree, the
- * `_$notifyConnectionChanged` API is patched onto ChildParts as a directive
- * climbs the parent tree, which is called by the core when clearing a part if
- * it exists. When called, that method iterates over the sparse tree of
- * Set<DisconnectableChildren> built up by AsyncDirectives, and calls
- * `_$notifyDirectiveConnectionChanged` on any directives that are encountered
- * in that tree, running the required callbacks.
- *
- * A given "logical tree" of lit-html data-structures might look like this:
- *
- *  ChildPart(N1) _$dC=[D2,T3]
- *   ._directive
- *     AsyncDirective(D2)
- *   ._value // user value was TemplateResult
- *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]
- *      ._parts[]
- *        AttributePart(A4) _$dC=[D5]
- *         ._directives[]
- *           AsyncDirective(D5)
- *        AttributePart(A6) _$dC=[D7,D8]
- *         ._directives[]
- *           AsyncDirective(D7)
- *           Directive(D8) _$dC=[D9]
- *            ._directive
- *              AsyncDirective(D9)
- *        ChildPart(N10) _$dC=[D11]
- *         ._directive
- *           AsyncDirective(D11)
- *         ._value
- *           string
- *        ChildPart(N12) _$dC=[D13,N14,N16]
- *         ._directive
- *           AsyncDirective(D13)
- *         ._value // user value was iterable
- *           Array<ChildPart>
- *             ChildPart(N14) _$dC=[D15]
- *              ._value
- *                string
- *             ChildPart(N16) _$dC=[D17,T18]
- *              ._directive
- *                AsyncDirective(D17)
- *              ._value // user value was TemplateResult
- *                TemplateInstance(T18) _$dC=[A19,A21,N25]
- *                 ._parts[]
- *                   AttributePart(A19) _$dC=[D20]
- *                    ._directives[]
- *                      AsyncDirective(D20)
- *                   AttributePart(A21) _$dC=[22,23]
- *                    ._directives[]
- *                      AsyncDirective(D22)
- *                      Directive(D23) _$dC=[D24]
- *                       ._directive
- *                         AsyncDirective(D24)
- *                   ChildPart(N25) _$dC=[D26]
- *                    ._directive
- *                      AsyncDirective(D26)
- *                    ._value
- *                      string
- *
- * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The
- * ChildPart will _clear() itself, and so we need to disconnect the "value" of
- * the ChildPart (but not its directive). In this case, when `_clear()` calls
- * `_$notifyConnectionChanged()`, we don't iterate all of the
- * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.
- * since the _value was an Array<ChildPart> (because an iterable had been
- * committed), we iterate the array of ChildParts (N14, N16) and run
- * `setConnected` on them (which does recurse down the full tree of
- * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's
- * `_$disconnectableChildren`). Once the values have been disconnected, we then
- * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty
- * (and would remove it from its parent TemplateInstance(T3) if so), but since
- * it would still contain its directive D13, it stays in the disconnectable
- * tree.
- *
- * Example 2: In the course of Example 1, `setConnected` will reach
- * ChildPart(N16); in this case the entire part is being disconnected, so we
- * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and
- * recursively run `setConnected` on them. Note that we only remove children
- * from `_$disconnectableChildren` for the top-level values being disconnected
- * on a clear; doing this bookkeeping lower in the tree is wasteful since it's
- * all being thrown away.
- *
- * Example 3: If the LitElement containing the entire tree above becomes
- * disconnected, it will run `childPart.setConnected()` (which calls
- * `childPart._$notifyConnectionChanged()` if it exists); in this case, we
- * recursively run `setConnected()` over the entire tree, without removing any
- * children from `_$disconnectableChildren`, since this tree is required to
- * re-connect the tree, which does the same operation, simply passing
- * `isConnectd: true` down the tree, signaling which callback to run.
- */
-import { Disconnectable, Part } from './lit-html';
-import { Directive } from './directive';
-export { directive } from './directive';
-/**
- * An abstract `Directive` base class whose `disconnected` method will be
- * called when the part containing the directive is cleared as a result of
- * re-rendering, or when the user calls `part.setConnected(false)` on
- * a part that was previously rendered containing the directive (as happens
- * when e.g. a LitElement disconnects from the DOM).
- *
- * If `part.setConnected(true)` is subsequently called on a
- * containing part, the directive's `reconnected` method will be called prior
- * to its next `update`/`render` callbacks. When implementing `disconnected`,
- * `reconnected` should also be implemented to be compatible with reconnection.
- *
- * Note that updates may occur while the directive is disconnected. As such,
- * directives should generally check the `this.isConnected` flag during
- * render/update to determine whether it is safe to subscribe to resources
- * that may prevent garbage collection.
- */
-export declare abstract class AsyncDirective extends Directive {
-    /**
-     * The connection state for this Directive.
-     */
-    isConnected: boolean;
-    /**
-     * Initialize the part with internal fields
-     * @param part
-     * @param parent
-     * @param attributeIndex
-     */
-    _$initialize(part: Part, parent: Disconnectable, attributeIndex: number | undefined): void;
-    /**
-     * Sets the value of the directive's Part outside the normal `update`/`render`
-     * lifecycle of a directive.
-     *
-     * This method should not be called synchronously from a directive's `update`
-     * or `render`.
-     *
-     * @param directive The directive to update
-     * @param value The value to set
-     */
-    setValue(value: unknown): void;
-    /**
-     * User callbacks for implementing logic to release any resources/subscriptions
-     * that may have been retained by this directive. Since directives may also be
-     * re-connected, `reconnected` should also be implemented to restore the
-     * working state of the directive prior to the next render.
-     */
-    protected disconnected(): void;
-    protected reconnected(): void;
-}