chrome-devtools-frontend 1.0.943182 → 1.0.944903

package/front_end/third_party/lit-html/package/README.md

@@ -1,135 +1,21 @@
-# lit-html 2.0 Pre-release
+# lit-html 2.0
 
 Efficient, Expressive, Extensible HTML templates in JavaScript
 
-[![Build Status](https://github.com/polymer/lit-html/workflows/Tests/badge.svg)](https://github.com/Polymer/lit-html/actions?query=workflow%3ATests)
-[![Published on npm](https://img.shields.io/npm/v/lit-html/next-major)](https://www.npmjs.com/package/lit-html)
+[![Build Status](https://github.com/lit/lit/workflows/Tests/badge.svg)](https://github.com/lit/lit/actions?query=workflow%3ATests)
+[![Published on npm](https://img.shields.io/npm/v/lit-html/next)](https://www.npmjs.com/package/lit-html)
 [![Join our Slack](https://img.shields.io/badge/slack-join%20chat-4a154b.svg)](https://www.polymer-project.org/slack-invite)
 [![Mentioned in Awesome Lit](https://awesome.re/mentioned-badge.svg)](https://github.com/web-padawan/awesome-lit)
 
-## 🚨 About this pre-release
-
-This is a major version pre-release of lit-html 2.0. See issue
-[#1182](https://github.com/Polymer/lit-html/issues/1182) for the full list of changes
-planned/considered for this release.
-
-This pre-release is not yet feature complete or API stable. Please note the
-breaking changes, known issues, and limitations below, and use at your risk
-until the stable release is available. Issues are welcome
-for unexpected changes not noted below or in the changelog.
-
-## 🚨 Breaking changes
-
-While `lit-html` 2.0 is intended to be a backward-compatible change for the
-majority of 1.x users, please be aware of the following notable breaking
-changes:
-
-- New `directive` and `Part` API (see below for migration info)
-- `render()` no longer clears its container on first render
-- Custom `templateFactory`, `TemplateProcessor`, and custom tag functions are no
-  longer supported
-- The `polyfill-support.js` file must be loaded when using the `webcomponents`
-  polyfills
-
-See the full [changelog](CHANGELOG.md) for more details on
-these and other minor breaking changes.
-
-## 🚨 Migrating directives
-
-While the API for _using_ directives should be 100% backward-compatible with
-1.x, there is a breaking change to how custom directives are _authored_. The API
-change improves ergonomics around making stateful directives while providing a
-clear pattern for SSR-compatible directives: only `render` will be called on the
-server, while `update` will not be.
-
-<details>
-<summary>Expand here for details on migrating directives.</summary>
-
-### Overview of directive API changes
-
-|                                              | 1.x API                                                                                           | 2.0 API                                                                 |
-| -------------------------------------------- | ------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| Code idiom for directive                     | function that takes directive arguments, and returns function that takes `part` and returns value | class with `update` & `render` methods which accept directive arguments |
-| Where to do declarative rendering            | pass value to `part.setValue()`                                                                   | return value from `render()` method                                     |
-| Where to do imperative DOM/part manipulation | directive function                                                                                | `update()` method                                                       |
-| Where state is stored between renders        | `WeakMap` keyed on `part`                                                                         | class instance fields                                                   |
-| How part validation is done                  | `instanceof` check on `part` in every render                                                      | `part.type` check in constructor                                        |
-
-### Example directive migration
-
-Below is an example of a lit-html 1.x directive, and how to migrate it to the
-new API:
-
-1.x Directive API:
-
-```js
-import {directive, NodePart, html} from 'lit-html';
-
-// State stored in WeakMap
-const previousState = new WeakMap();
-
-// Functional-based directive API
-export const renderCounter = directive((initialValue) => (part) => {
-  // When necessary, validate part type each render using `instanceof`
-  if (!(part instanceof NodePart)) {
-    throw new Error('renderCounter only supports NodePart');
-  }
-  // Retrieve value from previous state
-  let value = previousState.get(part);
-  // Update state
-  if (previous === undefined) {
-    value = initialValue;
-  } else {
-    value++;
-  }
-  // Store state
-  previousState.set(part, value);
-  // Update part with new rendering
-  part.setValue(html`<p>${value}</p>`);
-});
-```
+lit-html is the template system that powers the [Lit](https://lit.dev) library for building fast web components. When using `lit-html` to develop web components, most users should import lit-html via the [`lit`](https://www.npmjs.com/package/lit) package rather than installing and importing from `lit-html` directly.
 
-2.0 Directive API:
-
-```js
-import {html} from 'lit-html';
-import {directive, Directive, PartType} from 'lit-html/directive.js';
-
-// Class-based directive API
-export const renderCounter = directive(
-  class extends Directive {
-    // State stored in class field
-    value = undefined;
-    constructor(partInfo: PartInfo, index?: number) {
-      super(partInfo, index);
-      // When necessary, validate part in constructor using `part.type`
-      if (partInfo.type !== PartType.CHILD) {
-        throw new Error('renderCounter only supports child expressions');
-      }
-    }
-    // Any imperative updates to DOM/parts would go here
-    update(part, [initialValue]) {
-      // ...
-    }
-    // Do SSR-compatible rendering (arguments are passed from call site)
-    render(initialValue) {
-      // Previous state available on class field
-      if (this.value === undefined) {
-        this.value = initialValue;
-      } else {
-        this.value++;
-      }
-      return html`<p>${this.value}</p>`;
-    }
-  }
-);
-```
+## About this release
 
-</details>
+This is a stable release of `lit-html` 2.0 (part of the Lit 2.0 release). If upgrading from previous versions of `lit-html`, please note the minor breaking changes from lit-html 1.0 in the [Upgrade Guide](https://lit.dev/docs/releases/upgrade/).
 
-<hr>
+## Documentation
 
-# lit-html
+Full documentation is available at [lit.dev](https://lit.dev).
 
 ## Overview
 
@@ -161,48 +47,12 @@ render(helloTemplate('Kevin'), document.body);
 $ npm install lit-html
 ```
 
-## Development mode
-
-lit-html includes a development mode which adds additional checks that are
-reported in the console.
-
-To enable development mode, add the `development` exports condition to your node
-resolve configuration.
-
-#### @web/dev-server
-
-```js
-{
-  nodeResolve: {
-    exportConditions: ['development'],
-  }
-}
-```
+Or use from `lit`:
 
-#### Rollup
-
-```js
-{
-  plugins: [
-    nodeResolve({
-      exportConditions: ['development'],
-    }),
-  ],
-}
-```
-
-#### Webpack
-
-> NOTE: Requires [Webpack v5](https://webpack.js.org/migrate/5/)
-
-```js
-{
-  resolve: {
-    conditionNames: ['development'],
-  }
-}
+```bash
+$ npm install lit
 ```
 
 ## Contributing
 
-Please see [CONTRIBUTING.md](../../CONTRIBUTING.md).
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md).

package/front_end/third_party/lit-html/package/async-directive.d.ts

@@ -25,13 +25,14 @@
  * 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
- * disconnect (or reconnect) a tree, the `_$setChildPartConnected` 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 `_$setDirectiveConnected` on any
- * directives that are encountered in that tree, running the required callbacks.
+ * `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:
  *
@@ -87,7 +88,7 @@
  * 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
- * `_$setChildPartConnected()`, we don't iterate all of the
+ * `_$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
@@ -109,32 +110,37 @@
  *
  * Example 3: If the LitElement containing the entire tree above becomes
  * disconnected, it will run `childPart.setConnected()` (which calls
- * `childPart._$setChildPartConnected()` if it exists); in this case, we
+ * `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 { Directive } from './directive.js';
 import { Disconnectable, Part } from './lit-html.js';
-
+import { Directive } from './directive.js';
 export { directive } from './directive.js';
-
 /**
  * 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.setDirectiveConnection(false)` on
- * a part that was previously rendered containing the directive.
+ * 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.setDirectiveConnection(true)` is subsequently called on a
+ * 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;
-    private _pendingValue;
-    _$disconnetableChildren?: Set<Disconnectable>;
     /**
      * Initialize the part with internal fields
      * @param part
@@ -142,40 +148,6 @@ export declare abstract class AsyncDirective extends Directive {
      * @param attributeIndex
      */
     _$initialize(part: Part, parent: Disconnectable, attributeIndex: number | undefined): void;
-    /**
-     * Called from the core code when a directive is going away from a part (in
-     * which case `shouldRemoveFromParent` should be true), and from the
-     * `setChildrenConnected` helper function when recursively changing the
-     * connection state of a tree (in which case `shouldRemoveFromParent` should
-     * be false).
-     *
-     * @param isConnected
-     * @param isClearingDirective - True when the directive itself is being
-     *     removed; false when the tree is being disconnected
-     * @internal
-     */
-    _$setDirectiveConnected(isConnected: boolean, isClearingDirective?: boolean): void;
-    /**
-     * Private method used to set the connection state of the directive and call
-     * the respective `disconnected` or `reconnected` callback. Note thatsince
-     * `isConnected` defaults to true, we do not run `reconnected` on first
-     * render.
-     *
-     * If a call to `setValue` was made while disconnected, flush it to the part
-     * before reconnecting.
-     *
-     * @param isConnected
-     * @internal
-     */
-    private _setConnected;
-    /**
-     * Override of the base `_resolve` method to ensure `reconnected` is run
-     * prior to the next render.
-     *
-     * @override
-     * @internal
-     */
-    _$resolve(part: Part, props: Array<unknown>): unknown;
     /**
      * Sets the value of the directive's Part outside the normal `update`/`render`
      * lifecycle of a directive.
@@ -183,9 +155,6 @@ export declare abstract class AsyncDirective extends Directive {
      * This method should not be called synchronously from a directive's `update`
      * or `render`.
      *
-     * If the method is called while the part is disconnected, the value will be
-     * queued until directive is reconnected.
-     *
      * @param directive The directive to update
      * @param value The value to set
      */

package/front_end/third_party/lit-html/package/async-directive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-directive.d.ts","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+GG;AAEH,OAAO,EAGL,cAAc,EAEd,IAAI,EACL,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,SAAS,EAAqB,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAqJzC;;;;;;;;;;GAUG;AACH,8BAAsB,cAAe,SAAQ,SAAS;IACpD,WAAW,UAAQ;IACnB,OAAO,CAAC,aAAa,CAAqB;IAE1C,uBAAuB,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAa;IAC1D;;;;;OAKG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS;IAKpC;;;;;;;;;;;OAWG;IACH,uBAAuB,CAAC,WAAW,EAAE,OAAO,EAAE,mBAAmB,UAAO;IAOxE;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAgBrB;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO;IAUrD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO;IAmBvB;;;;;OAKG;IACH,SAAS,CAAC,YAAY;IACtB,SAAS,CAAC,WAAW;CACtB"}
+{"version":3,"file":"async-directive.d.ts","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AAEH,OAAO,EAA2B,cAAc,EAAE,IAAI,EAAC,MAAM,eAAe,CAAC;AAE7E,OAAO,EAAC,SAAS,EAAqB,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AA0JzC;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,cAAe,SAAQ,SAAS;IAMpD;;OAEG;IACH,WAAW,EAAG,OAAO,CAAC;IAItB;;;;;OAKG;IACM,YAAY,CACnB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS;IAqCpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO;IAevB;;;;;OAKG;IACH,SAAS,CAAC,YAAY;IACtB,SAAS,CAAC,WAAW;CACtB"}

package/front_end/third_party/lit-html/package/async-directive.js

@@ -1,12 +1,7 @@
-import{isSingleExpression as e}from"./directive-helpers.js";
-import{Directive as t,PartType as s}from"./directive.js";
-import{noChange as i}from"./lit-html.js";
-
-export{directive}from"./directive.js";
-
+import{isSingleExpression as i}from"./directive-helpers.js";import{Directive as t,PartType as s}from"./directive.js";export{directive}from"./directive.js";
 /**
  * @license
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */const r=(i,t)=>{var s,e;const o=i.N;if(void 0===o)return!1;for(const i of o)null===(e=(s=i).O)||void 0===e||e.call(s,t,!1),r(i,t);return!0},o=i=>{let t,s;do{if(void 0===(t=i.M))break;s=t.N,s.delete(i),i=t}while(0===(null==s?void 0:s.size))},h=i=>{for(let t;t=i.M;i=t){let s=t.N;if(void 0===s)t.N=s=new Set;else if(s.has(i))break;s.add(i),d(t)}};function n(i){void 0!==this.N?(o(this),this.M=i,h(this)):this.M=i}function l(i,t=!1,s=0){const e=this.H,h=this.N;if(void 0!==h&&0!==h.size)if(t)if(Array.isArray(e))for(let i=s;i<e.length;i++)r(e[i],!1),o(e[i]);else null!=e&&(r(e,!1),o(e));else r(this,i)}const d=i=>{var t,e,r,o;i.type==s.CHILD&&(null!==(t=(r=i).P)&&void 0!==t||(r.P=l),null!==(e=(o=i).Q)&&void 0!==e||(o.Q=n))};class c extends t{constructor(){super(...arguments),this.isConnected=!0,this.ut=i,this.N=void 0}T(i,t,s){super.T(i,t,s),h(this)}O(i,t=!0){this.at(i),t&&(r(this,i),o(this))}at(t){var s,e;t!==this.isConnected&&(t?(this.isConnected=!0,this.ut!==i&&(this.setValue(this.ut),this.ut=i),null===(s=this.reconnected)||void 0===s||s.call(this)):(this.isConnected=!1,null===(e=this.disconnected)||void 0===e||e.call(this)))}S(i,t){if(!this.isConnected)throw Error(`AsyncDirective ${this.constructor.name} was rendered while its tree was disconnected.`);return super.S(i,t)}setValue(i){if(this.isConnected)if(e(this.Σdt))this.Σdt.I(i,this);else{const t=[...this.Σdt.H];t[this.Σct]=i,this.Σdt.I(t,this,0)}else this.ut=i}disconnected(){}reconnected(){}}export{c as AsyncDirective};
+ */const e=(i,t)=>{var s,o;const n=i._$AN;if(void 0===n)return!1;for(const i of n)null===(o=(s=i)._$AO)||void 0===o||o.call(s,t,!1),e(i,t);return!0},o=i=>{let t,s;do{if(void 0===(t=i._$AM))break;s=t._$AN,s.delete(i),i=t}while(0===(null==s?void 0:s.size))},n=i=>{for(let t;t=i._$AM;i=t){let s=t._$AN;if(void 0===s)t._$AN=s=new Set;else if(s.has(i))break;s.add(i),l(t)}};function r(i){void 0!==this._$AN?(o(this),this._$AM=i,n(this)):this._$AM=i}function h(i,t=!1,s=0){const n=this._$AH,r=this._$AN;if(void 0!==r&&0!==r.size)if(t)if(Array.isArray(n))for(let i=s;i<n.length;i++)e(n[i],!1),o(n[i]);else null!=n&&(e(n,!1),o(n));else e(this,i)}const l=i=>{var t,e,o,n;i.type==s.CHILD&&(null!==(t=(o=i)._$AP)&&void 0!==t||(o._$AP=h),null!==(e=(n=i)._$AQ)&&void 0!==e||(n._$AQ=r))};class d extends t{constructor(){super(...arguments),this._$AN=void 0}_$AT(i,t,s){super._$AT(i,t,s),n(this),this.isConnected=i._$AU}_$AO(i,t=!0){var s,n;i!==this.isConnected&&(this.isConnected=i,i?null===(s=this.reconnected)||void 0===s||s.call(this):null===(n=this.disconnected)||void 0===n||n.call(this)),t&&(e(this,i),o(this))}setValue(t){if(i(this._$Ct))this._$Ct._$AI(t,this);else{const i=[...this._$Ct._$AH];i[this._$Ci]=t,this._$Ct._$AI(i,this,0)}}disconnected(){}reconnected(){}}export{d as AsyncDirective};
 //# sourceMappingURL=async-directive.js.map

package/front_end/third_party/lit-html/package/async-directive.js.map

@@ -1 +1 @@
-{"version":3,"file":"async-directive.js","sources":["src/async-directive.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * Overview:\n *\n * This module is designed to add support for an async `setValue` API and\n * `disconnected` callback to directives with the least impact on the core\n * runtime or payload when that feature is not used.\n *\n * The strategy is to introduce a `AsyncDirective` subclass of\n * `Directive` that climbs the \"parent\" tree in its constructor to note which\n * branches of lit-html's \"logical tree\" of data structures contain such\n * directives and thus need to be crawled when a subtree is being cleared (or\n * manually disconnected) in order to run the `disconnected` callback.\n *\n * The \"nodes\" of the logical tree include Parts, TemplateInstances (for when a\n * TemplateResult is committed to a value of a ChildPart), and Directives; these\n * all implement a common interface called `DisconnectableChild`. Each has a\n * `_$parent` reference which is set during construction in the core code, and a\n * `_$disconnectableChildren` field which is initially undefined.\n *\n * The sparse tree created by means of the `AsyncDirective` constructor\n * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set\n * on each parent that includes each child that contains a\n * `AsyncDirective` directly or transitively via its children. In order\n * disconnect (or reconnect) a tree, the `_$setChildPartConnected` API is patched\n * onto ChildParts as a directive climbs the parent tree, which is called by the\n * core when clearing a part if it exists. When called, that method iterates\n * over the sparse tree of Set<DisconnectableChildren> built up by\n * AsyncDirectives, and calls `_$setDirectiveConnected` on any\n * directives that are encountered in that tree, running the required callbacks.\n *\n * A given \"logical tree\" of lit-html data-structures might look like this:\n *\n *  ChildPart(N1) _$dC=[D2,T3]\n *   ._directive\n *     AsyncDirective(D2)\n *   ._value // user value was TemplateResult\n *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]\n *      ._parts[]\n *        AttributePart(A4) _$dC=[D5]\n *         ._directives[]\n *           AsyncDirective(D5)\n *        AttributePart(A6) _$dC=[D7,D8]\n *         ._directives[]\n *           AsyncDirective(D7)\n *           Directive(D8) _$dC=[D9]\n *            ._directive\n *              AsyncDirective(D9)\n *        ChildPart(N10) _$dC=[D11]\n *         ._directive\n *           AsyncDirective(D11)\n *         ._value\n *           string\n *        ChildPart(N12) _$dC=[D13,N14,N16]\n *         ._directive\n *           AsyncDirective(D13)\n *         ._value // user value was iterable\n *           Array<ChildPart>\n *             ChildPart(N14) _$dC=[D15]\n *              ._value\n *                string\n *             ChildPart(N16) _$dC=[D17,T18]\n *              ._directive\n *                AsyncDirective(D17)\n *              ._value // user value was TemplateResult\n *                TemplateInstance(T18) _$dC=[A19,A21,N25]\n *                 ._parts[]\n *                   AttributePart(A19) _$dC=[D20]\n *                    ._directives[]\n *                      AsyncDirective(D20)\n *                   AttributePart(A21) _$dC=[22,23]\n *                    ._directives[]\n *                      AsyncDirective(D22)\n *                      Directive(D23) _$dC=[D24]\n *                       ._directive\n *                         AsyncDirective(D24)\n *                   ChildPart(N25) _$dC=[D26]\n *                    ._directive\n *                      AsyncDirective(D26)\n *                    ._value\n *                      string\n *\n * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The\n * ChildPart will _clear() itself, and so we need to disconnect the \"value\" of\n * the ChildPart (but not its directive). In this case, when `_clear()` calls\n * `_$setChildPartConnected()`, we don't iterate all of the\n * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.\n * since the _value was an Array<ChildPart> (because an iterable had been\n * committed), we iterate the array of ChildParts (N14, N16) and run\n * `setConnected` on them (which does recurse down the full tree of\n * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's\n * `_$disconnectableChildren`). Once the values have been disconnected, we then\n * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty\n * (and would remove it from its parent TemplateInstance(T3) if so), but since\n * it would still contain its directive D13, it stays in the disconnectable\n * tree.\n *\n * Example 2: In the course of Example 1, `setConnected` will reach\n * ChildPart(N16); in this case the entire part is being disconnected, so we\n * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and\n * recursively run `setConnected` on them. Note that we only remove children\n * from `_$disconnectableChildren` for the top-level values being disconnected\n * on a clear; doing this bookkeeping lower in the tree is wasteful since it's\n * all being thrown away.\n *\n * Example 3: If the LitElement containing the entire tree above becomes\n * disconnected, it will run `childPart.setConnected()` (which calls\n * `childPart._$setChildPartConnected()` if it exists); in this case, we\n * recursively run `setConnected()` over the entire tree, without removing any\n * children from `_$disconnectableChildren`, since this tree is required to\n * re-connect the tree, which does the same operation, simply passing\n * `isConnectd: true` down the tree, signaling which callback to run.\n */\n\nimport {\n  AttributePart,\n  ChildPart,\n  Disconnectable,\n  noChange,\n  Part,\n} from './lit-html.js';\nimport {isSingleExpression} from './directive-helpers.js';\nimport {Directive, PartInfo, PartType} from './directive.js';\nexport {directive} from './directive.js';\n\nconst DEV_MODE = true;\n\n/**\n * Recursively walks down the tree of Parts/TemplateInstances/Directives to set\n * the connected state of directives and run `disconnected`/ `reconnected`\n * callbacks.\n *\n * @return True if there were children to disconnect; false otherwise\n */\nconst setChildrenConnected = (\n  parent: Disconnectable,\n  isConnected: boolean\n): boolean => {\n  const children = parent._$disconnetableChildren;\n  if (children === undefined) {\n    return false;\n  }\n  for (const obj of children) {\n    // The existence of `_$setDirectiveConnected` is used as a \"brand\" to\n    // disambiguate AsyncDirectives from other DisconnectableChildren\n    // (as opposed to using an instanceof check to know when to call it); the\n    // redundancy of \"Directive\" in the API name is to avoid conflicting with\n    // `_$setChildPartConnected`, which exists `ChildParts` which are also in\n    // this list\n    // Disconnect Directive (and any nested directives contained within)\n    (obj as AsyncDirective)._$setDirectiveConnected?.(isConnected, false);\n    // Disconnect Part/TemplateInstance\n    setChildrenConnected(obj, isConnected);\n  }\n  return true;\n};\n\n/**\n * Removes the given child from its parent list of disconnectable children, and\n * if the parent list becomes empty as a result, removes the parent from its\n * parent, and so forth up the tree when that causes subsequent parent lists to\n * become empty.\n */\nconst removeDisconnectableFromParent = (obj: Disconnectable) => {\n  let parent, children;\n  do {\n    if ((parent = obj._$parent) === undefined) {\n      break;\n    }\n    children = parent._$disconnetableChildren!;\n    children.delete(obj);\n    obj = parent;\n  } while (children?.size === 0);\n};\n\nconst addDisconnectableToParent = (obj: Disconnectable) => {\n  // Climb the parent tree, creating a sparse tree of children needing\n  // disconnection\n  for (let parent; (parent = obj._$parent); obj = parent) {\n    let children = parent._$disconnetableChildren;\n    if (children === undefined) {\n      parent._$disconnetableChildren = children = new Set();\n    } else if (children.has(obj)) {\n      // Once we've reached a parent that already contains this child, we\n      // can short-circuit\n      break;\n    }\n    children.add(obj);\n    installDisconnectAPI(parent);\n  }\n};\n\n/**\n * Changes the parent reference of the ChildPart, and updates the sparse tree of\n * Disconnectable children accordingly.\n *\n * Note, this method will be patched onto ChildPart instances and called from\n * the core code when parts are moved between different parents.\n */\nfunction reparentDisconnectables(this: ChildPart, newParent: Disconnectable) {\n  if (this._$disconnetableChildren !== undefined) {\n    removeDisconnectableFromParent(this);\n    this._$parent = newParent;\n    addDisconnectableToParent(this);\n  } else {\n    this._$parent = newParent;\n  }\n}\n\n/**\n * Sets the connected state on any directives contained within the committed\n * value of this part (i.e. within a TemplateInstance or iterable of\n * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within\n * any directives stored on the ChildPart (when `valueOnly` is false).\n *\n * `isClearingValue` should be passed as `true` on a top-level part that is\n * clearing itself, and not as a result of recursively disconnecting directives\n * as part of a `clear` operation higher up the tree. This both ensures that any\n * directive on this ChildPart that produced a value that caused the clear\n * operation is not disconnected, and also serves as a performance optimization\n * to avoid needless bookkeeping when a subtree is going away; when clearing a\n * subtree, only the top-most part need to remove itself from the parent.\n *\n * `fromPartIndex` is passed only in the case of a partial `_clear` running as a\n * result of truncating an iterable.\n *\n * Note, this method will be patched onto ChildPart instances and called from the\n * core code when parts are cleared or the connection state is changed by the\n * user.\n */\nfunction setChildPartConnected(\n  this: ChildPart,\n  isConnected: boolean,\n  isClearingValue = false,\n  fromPartIndex = 0\n) {\n  const value = this._$committedValue;\n  const children = this._$disconnetableChildren;\n  if (children === undefined || children.size === 0) {\n    return;\n  }\n  if (isClearingValue) {\n    if (Array.isArray(value)) {\n      // Iterable case: Any ChildParts created by the iterable should be\n      // disconnected and removed from this ChildPart's disconnectable\n      // children (starting at `fromPartIndex` in the case of truncation)\n      for (let i = fromPartIndex; i < value.length; i++) {\n        setChildrenConnected(value[i], false);\n        removeDisconnectableFromParent(value[i]);\n      }\n    } else if (value != null) {\n      // TemplateInstance case: If the value has disconnectable children (will\n      // only be in the case that it is a TemplateInstance), we disconnect it\n      // and remove it from this ChildPart's disconnectable children\n      setChildrenConnected(value as Disconnectable, false);\n      removeDisconnectableFromParent(value as Disconnectable);\n    }\n  } else {\n    setChildrenConnected(this, isConnected);\n  }\n}\n\n/**\n * Patches disconnection API onto ChildParts.\n */\nconst installDisconnectAPI = (obj: Disconnectable) => {\n  if ((obj as ChildPart).type == PartType.CHILD) {\n    (obj as ChildPart)._$setChildPartConnected ??= setChildPartConnected;\n    (obj as ChildPart)._$reparentDisconnectables ??= reparentDisconnectables;\n  }\n};\n\n/**\n * An abstract `Directive` base class whose `disconnected` method will be\n * called when the part containing the directive is cleared as a result of\n * re-rendering, or when the user calls `part.setDirectiveConnection(false)` on\n * a part that was previously rendered containing the directive.\n *\n * If `part.setDirectiveConnection(true)` is subsequently called on a\n * containing part, the directive's `reconnected` method will be called prior\n * to its next `update`/`render` callbacks. When implementing `disconnected`,\n * `reconnected` should also be implemented to be compatible with reconnection.\n */\nexport abstract class AsyncDirective extends Directive {\n  isConnected = true;\n  private _pendingValue: unknown = noChange;\n  // @internal\n  _$disconnetableChildren?: Set<Disconnectable> = undefined;\n  /**\n   * Initialize the part with internal fields\n   * @param part\n   * @param parent\n   * @param attributeIndex\n   */\n  _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined\n  ) {\n    super._$initialize(part, parent, attributeIndex);\n    addDisconnectableToParent(this);\n  }\n  /**\n   * Called from the core code when a directive is going away from a part (in\n   * which case `shouldRemoveFromParent` should be true), and from the\n   * `setChildrenConnected` helper function when recursively changing the\n   * connection state of a tree (in which case `shouldRemoveFromParent` should\n   * be false).\n   *\n   * @param isConnected\n   * @param isClearingDirective - True when the directive itself is being\n   *     removed; false when the tree is being disconnected\n   * @internal\n   */\n  _$setDirectiveConnected(isConnected: boolean, isClearingDirective = true) {\n    this._setConnected(isConnected);\n    if (isClearingDirective) {\n      setChildrenConnected(this, isConnected);\n      removeDisconnectableFromParent(this);\n    }\n  }\n  /**\n   * Private method used to set the connection state of the directive and call\n   * the respective `disconnected` or `reconnected` callback. Note thatsince\n   * `isConnected` defaults to true, we do not run `reconnected` on first\n   * render.\n   *\n   * If a call to `setValue` was made while disconnected, flush it to the part\n   * before reconnecting.\n   *\n   * @param isConnected\n   * @internal\n   */\n  private _setConnected(isConnected: boolean) {\n    if (isConnected !== this.isConnected) {\n      if (isConnected) {\n        this.isConnected = true;\n        if (this._pendingValue !== noChange) {\n          this.setValue(this._pendingValue);\n          this._pendingValue = noChange;\n        }\n        this.reconnected?.();\n      } else {\n        this.isConnected = false;\n        this.disconnected?.();\n      }\n    }\n  }\n\n  /**\n   * Override of the base `_resolve` method to ensure `reconnected` is run\n   * prior to the next render.\n   *\n   * @override\n   * @internal\n   */\n  _$resolve(part: Part, props: Array<unknown>): unknown {\n    if (!this.isConnected) {\n      throw new Error(\n        `AsyncDirective ${this.constructor.name} was ` +\n          `rendered while its tree was disconnected.`\n      );\n    }\n    return super._$resolve(part, props);\n  }\n\n  /**\n   * Sets the value of the directive's Part outside the normal `update`/`render`\n   * lifecycle of a directive.\n   *\n   * This method should not be called synchronously from a directive's `update`\n   * or `render`.\n   *\n   * If the method is called while the part is disconnected, the value will be\n   * queued until directive is reconnected.\n   *\n   * @param directive The directive to update\n   * @param value The value to set\n   */\n  setValue(value: unknown) {\n    if (this.isConnected) {\n      if (isSingleExpression((this.__part as unknown) as PartInfo)) {\n        this.__part._$setValue(value, this);\n      } else {\n        // this.__attributeIndex will be defined in this case, but\n        // assert it in dev mode\n        if (DEV_MODE && this.__attributeIndex === undefined) {\n          throw new Error(`Expected this.__attributeIndex to be a number`);\n        }\n        const newValues = [...(this.__part._$committedValue as Array<unknown>)];\n        newValues[this.__attributeIndex!] = value;\n        (this.__part as AttributePart)._$setValue(newValues, this, 0);\n      }\n    } else {\n      this._pendingValue = value;\n    }\n  }\n\n  /**\n   * User callbacks for implementing logic to release any resources/subscriptions\n   * that may have been retained by this directive. Since directives may also be\n   * re-connected, `reconnected` should also be implemented to restore the\n   * working state of the directive prior to the next render.\n   */\n  protected disconnected() {}\n  protected reconnected() {}\n}\n"],"names":["setChildrenConnected","parent","isConnected","children","_$disconnetableChildren","undefined","obj","_$setDirectiveConnected","removeDisconnectableFromParent","_$parent","delete","size","addDisconnectableToParent","Set","has","add","installDisconnectAPI","reparentDisconnectables","newParent","this","setChildPartConnected","isClearingValue","fromPartIndex","value","_$committedValue","Array","isArray","i","length","type","PartType","CHILD","_$setChildPartConnected","_$reparentDisconnectables","AsyncDirective","Directive","[object Object]","noChange","part","attributeIndex","super","_$initialize","isClearingDirective","_setConnected","_pendingValue","setValue","reconnected","disconnected","props","Error","constructor","name","_$resolve","isSingleExpression","__part","_$setValue","newValues","__attributeIndex"],"mappings":";;;;;GA2IA,MAAMA,EAAuB,CAC3BC,EACAC,aAEA,MAAMC,EAAWF,EAAOG,EACxB,QAAiBC,IAAbF,EACF,OAAO,EAET,IAAK,MAAMG,KAAOH,eAQfG,GAAuBC,yBAA0BL,GAAa,GAE/DF,EAAqBM,EAAKJ,GAE5B,OAAO,GASHM,EAAkCF,IACtC,IAAIL,EAAQE,EACZ,EAAG,CACD,QAAgCE,KAA3BJ,EAASK,EAAIG,GAChB,MAEFN,EAAWF,EAAOG,EAClBD,EAASO,OAAOJ,GAChBA,EAAML,QACoB,KAAnBE,MAAAA,SAAAA,EAAUQ,QAGfC,EAA6BN,IAGjC,IAAK,IAAIL,EAASA,EAASK,EAAIG,EAAWH,EAAML,EAAQ,CACtD,IAAIE,EAAWF,EAAOG,EACtB,QAAiBC,IAAbF,EACFF,EAAOG,EAA0BD,EAAW,IAAIU,SAC3C,GAAIV,EAASW,IAAIR,GAGtB,MAEFH,EAASY,IAAIT,GACbU,EAAqBf,KAWzB,SAASgB,EAAyCC,QACXb,IAAjCc,KAAKf,GACPI,EAA+BW,MAC/BA,KAAKV,EAAWS,EAChBN,EAA0BO,OAE1BA,KAAKV,EAAWS,EAyBpB,SAASE,EAEPlB,EACAmB,GAAkB,EAClBC,EAAgB,GAEhB,MAAMC,EAAQJ,KAAKK,EACbrB,EAAWgB,KAAKf,EACtB,QAAiBC,IAAbF,GAA4C,IAAlBA,EAASQ,KAGvC,GAAIU,EACF,GAAII,MAAMC,QAAQH,GAIhB,IAAK,IAAII,EAAIL,EAAeK,EAAIJ,EAAMK,OAAQD,IAC5C3B,EAAqBuB,EAAMI,IAAI,GAC/BnB,EAA+Be,EAAMI,SAErB,MAATJ,IAITvB,EAAqBuB,GAAyB,GAC9Cf,EAA+Be,SAGjCvB,EAAqBmB,KAAMjB,GAO/B,MAAMc,EAAwBV,gBACvBA,EAAkBuB,MAAQC,EAASC,qBACrCzB,GAAkB0B,mBAAAA,EAA4BZ,gBAC9Cd,GAAkB2B,mBAAAA,EAA8BhB,WAe/BiB,UAAuBC,EAA7CC,kCACEjB,kBAAc,EACNA,QAAyBkB,EAEjClB,YAAgDd,EAOhD+B,EACEE,EACArC,EACAsC,GAEAC,MAAMC,EAAaH,EAAMrC,EAAQsC,GACjC3B,EAA0BO,MAc5BiB,EAAwBlC,EAAsBwC,GAAsB,GAClEvB,KAAKwB,GAAczC,GACfwC,IACF1C,EAAqBmB,KAAMjB,GAC3BM,EAA+BW,OAe3BiB,GAAclC,WAChBA,IAAgBiB,KAAKjB,cACnBA,GACFiB,KAAKjB,aAAc,EACfiB,KAAKyB,KAAkBP,IACzBlB,KAAK0B,SAAS1B,KAAKyB,IACnBzB,KAAKyB,GAAgBP,aAEvBlB,KAAK2B,iCAAL3B,QAEAA,KAAKjB,aAAc,YACnBiB,KAAK4B,kCAAL5B,QAYNiB,EAAUE,EAAYU,GACpB,IAAK7B,KAAKjB,YACR,MAAU+C,MACR,kBAAkB9B,KAAK+B,YAAYC,sDAIvC,OAAOX,MAAMY,EAAUd,EAAMU,GAgB/BZ,SAASb,GACP,GAAIJ,KAAKjB,YACP,GAAImD,EAAoBlC,KAAKmC,KAC3BnC,KAAKmC,IAAOC,EAAWhC,EAAOJ,UACzB,CAML,MAAMqC,EAAY,IAAKrC,KAAKmC,IAAO9B,GACnCgC,EAAUrC,KAAKsC,KAAqBlC,EACnCJ,KAAKmC,IAAyBC,EAAWC,EAAWrC,KAAM,QAG7DA,KAAKyB,GAAgBrB,EAUfa,gBACAA"}
+{"version":3,"file":"async-directive.js","sources":["src/async-directive.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * Overview:\n *\n * This module is designed to add support for an async `setValue` API and\n * `disconnected` callback to directives with the least impact on the core\n * runtime or payload when that feature is not used.\n *\n * The strategy is to introduce a `AsyncDirective` subclass of\n * `Directive` that climbs the \"parent\" tree in its constructor to note which\n * branches of lit-html's \"logical tree\" of data structures contain such\n * directives and thus need to be crawled when a subtree is being cleared (or\n * manually disconnected) in order to run the `disconnected` callback.\n *\n * The \"nodes\" of the logical tree include Parts, TemplateInstances (for when a\n * TemplateResult is committed to a value of a ChildPart), and Directives; these\n * all implement a common interface called `DisconnectableChild`. Each has a\n * `_$parent` reference which is set during construction in the core code, and a\n * `_$disconnectableChildren` field which is initially undefined.\n *\n * The sparse tree created by means of the `AsyncDirective` constructor\n * crawling up the `_$parent` tree and placing a `_$disconnectableChildren` Set\n * on each parent that includes each child that contains a\n * `AsyncDirective` directly or transitively via its children. In order to\n * notify connection state changes and disconnect (or reconnect) a tree, the\n * `_$notifyConnectionChanged` API is patched onto ChildParts as a directive\n * climbs the parent tree, which is called by the core when clearing a part if\n * it exists. When called, that method iterates over the sparse tree of\n * Set<DisconnectableChildren> built up by AsyncDirectives, and calls\n * `_$notifyDirectiveConnectionChanged` on any directives that are encountered\n * in that tree, running the required callbacks.\n *\n * A given \"logical tree\" of lit-html data-structures might look like this:\n *\n *  ChildPart(N1) _$dC=[D2,T3]\n *   ._directive\n *     AsyncDirective(D2)\n *   ._value // user value was TemplateResult\n *     TemplateInstance(T3) _$dC=[A4,A6,N10,N12]\n *      ._parts[]\n *        AttributePart(A4) _$dC=[D5]\n *         ._directives[]\n *           AsyncDirective(D5)\n *        AttributePart(A6) _$dC=[D7,D8]\n *         ._directives[]\n *           AsyncDirective(D7)\n *           Directive(D8) _$dC=[D9]\n *            ._directive\n *              AsyncDirective(D9)\n *        ChildPart(N10) _$dC=[D11]\n *         ._directive\n *           AsyncDirective(D11)\n *         ._value\n *           string\n *        ChildPart(N12) _$dC=[D13,N14,N16]\n *         ._directive\n *           AsyncDirective(D13)\n *         ._value // user value was iterable\n *           Array<ChildPart>\n *             ChildPart(N14) _$dC=[D15]\n *              ._value\n *                string\n *             ChildPart(N16) _$dC=[D17,T18]\n *              ._directive\n *                AsyncDirective(D17)\n *              ._value // user value was TemplateResult\n *                TemplateInstance(T18) _$dC=[A19,A21,N25]\n *                 ._parts[]\n *                   AttributePart(A19) _$dC=[D20]\n *                    ._directives[]\n *                      AsyncDirective(D20)\n *                   AttributePart(A21) _$dC=[22,23]\n *                    ._directives[]\n *                      AsyncDirective(D22)\n *                      Directive(D23) _$dC=[D24]\n *                       ._directive\n *                         AsyncDirective(D24)\n *                   ChildPart(N25) _$dC=[D26]\n *                    ._directive\n *                      AsyncDirective(D26)\n *                    ._value\n *                      string\n *\n * Example 1: The directive in ChildPart(N12) updates and returns `nothing`. The\n * ChildPart will _clear() itself, and so we need to disconnect the \"value\" of\n * the ChildPart (but not its directive). In this case, when `_clear()` calls\n * `_$notifyConnectionChanged()`, we don't iterate all of the\n * _$disconnectableChildren, rather we do a value-specific disconnection: i.e.\n * since the _value was an Array<ChildPart> (because an iterable had been\n * committed), we iterate the array of ChildParts (N14, N16) and run\n * `setConnected` on them (which does recurse down the full tree of\n * `_$disconnectableChildren` below it, and also removes N14 and N16 from N12's\n * `_$disconnectableChildren`). Once the values have been disconnected, we then\n * check whether the ChildPart(N12)'s list of `_$disconnectableChildren` is empty\n * (and would remove it from its parent TemplateInstance(T3) if so), but since\n * it would still contain its directive D13, it stays in the disconnectable\n * tree.\n *\n * Example 2: In the course of Example 1, `setConnected` will reach\n * ChildPart(N16); in this case the entire part is being disconnected, so we\n * simply iterate all of N16's `_$disconnectableChildren` (D17,T18) and\n * recursively run `setConnected` on them. Note that we only remove children\n * from `_$disconnectableChildren` for the top-level values being disconnected\n * on a clear; doing this bookkeeping lower in the tree is wasteful since it's\n * all being thrown away.\n *\n * Example 3: If the LitElement containing the entire tree above becomes\n * disconnected, it will run `childPart.setConnected()` (which calls\n * `childPart._$notifyConnectionChanged()` if it exists); in this case, we\n * recursively run `setConnected()` over the entire tree, without removing any\n * children from `_$disconnectableChildren`, since this tree is required to\n * re-connect the tree, which does the same operation, simply passing\n * `isConnectd: true` down the tree, signaling which callback to run.\n */\n\nimport {AttributePart, ChildPart, Disconnectable, Part} from './lit-html.js';\nimport {isSingleExpression} from './directive-helpers.js';\nimport {Directive, PartInfo, PartType} from './directive.js';\nexport {directive} from './directive.js';\n\nconst DEV_MODE = true;\n\n/**\n * Recursively walks down the tree of Parts/TemplateInstances/Directives to set\n * the connected state of directives and run `disconnected`/ `reconnected`\n * callbacks.\n *\n * @return True if there were children to disconnect; false otherwise\n */\nconst notifyChildrenConnectedChanged = (\n  parent: Disconnectable,\n  isConnected: boolean\n): boolean => {\n  const children = parent._$disconnectableChildren;\n  if (children === undefined) {\n    return false;\n  }\n  for (const obj of children) {\n    // The existence of `_$notifyDirectiveConnectionChanged` is used as a \"brand\" to\n    // disambiguate AsyncDirectives from other DisconnectableChildren\n    // (as opposed to using an instanceof check to know when to call it); the\n    // redundancy of \"Directive\" in the API name is to avoid conflicting with\n    // `_$notifyConnectionChanged`, which exists `ChildParts` which are also in\n    // this list\n    // Disconnect Directive (and any nested directives contained within)\n    // This property needs to remain unminified.\n    (obj as AsyncDirective)['_$notifyDirectiveConnectionChanged']?.(\n      isConnected,\n      false\n    );\n    // Disconnect Part/TemplateInstance\n    notifyChildrenConnectedChanged(obj, isConnected);\n  }\n  return true;\n};\n\n/**\n * Removes the given child from its parent list of disconnectable children, and\n * if the parent list becomes empty as a result, removes the parent from its\n * parent, and so forth up the tree when that causes subsequent parent lists to\n * become empty.\n */\nconst removeDisconnectableFromParent = (obj: Disconnectable) => {\n  let parent, children;\n  do {\n    if ((parent = obj._$parent) === undefined) {\n      break;\n    }\n    children = parent._$disconnectableChildren!;\n    children.delete(obj);\n    obj = parent;\n  } while (children?.size === 0);\n};\n\nconst addDisconnectableToParent = (obj: Disconnectable) => {\n  // Climb the parent tree, creating a sparse tree of children needing\n  // disconnection\n  for (let parent; (parent = obj._$parent); obj = parent) {\n    let children = parent._$disconnectableChildren;\n    if (children === undefined) {\n      parent._$disconnectableChildren = children = new Set();\n    } else if (children.has(obj)) {\n      // Once we've reached a parent that already contains this child, we\n      // can short-circuit\n      break;\n    }\n    children.add(obj);\n    installDisconnectAPI(parent);\n  }\n};\n\n/**\n * Changes the parent reference of the ChildPart, and updates the sparse tree of\n * Disconnectable children accordingly.\n *\n * Note, this method will be patched onto ChildPart instances and called from\n * the core code when parts are moved between different parents.\n */\nfunction reparentDisconnectables(this: ChildPart, newParent: Disconnectable) {\n  if (this._$disconnectableChildren !== undefined) {\n    removeDisconnectableFromParent(this);\n    this._$parent = newParent;\n    addDisconnectableToParent(this);\n  } else {\n    this._$parent = newParent;\n  }\n}\n\n/**\n * Sets the connected state on any directives contained within the committed\n * value of this part (i.e. within a TemplateInstance or iterable of\n * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within\n * any directives stored on the ChildPart (when `valueOnly` is false).\n *\n * `isClearingValue` should be passed as `true` on a top-level part that is\n * clearing itself, and not as a result of recursively disconnecting directives\n * as part of a `clear` operation higher up the tree. This both ensures that any\n * directive on this ChildPart that produced a value that caused the clear\n * operation is not disconnected, and also serves as a performance optimization\n * to avoid needless bookkeeping when a subtree is going away; when clearing a\n * subtree, only the top-most part need to remove itself from the parent.\n *\n * `fromPartIndex` is passed only in the case of a partial `_clear` running as a\n * result of truncating an iterable.\n *\n * Note, this method will be patched onto ChildPart instances and called from the\n * core code when parts are cleared or the connection state is changed by the\n * user.\n */\nfunction notifyChildPartConnectedChanged(\n  this: ChildPart,\n  isConnected: boolean,\n  isClearingValue = false,\n  fromPartIndex = 0\n) {\n  const value = this._$committedValue;\n  const children = this._$disconnectableChildren;\n  if (children === undefined || children.size === 0) {\n    return;\n  }\n  if (isClearingValue) {\n    if (Array.isArray(value)) {\n      // Iterable case: Any ChildParts created by the iterable should be\n      // disconnected and removed from this ChildPart's disconnectable\n      // children (starting at `fromPartIndex` in the case of truncation)\n      for (let i = fromPartIndex; i < value.length; i++) {\n        notifyChildrenConnectedChanged(value[i], false);\n        removeDisconnectableFromParent(value[i]);\n      }\n    } else if (value != null) {\n      // TemplateInstance case: If the value has disconnectable children (will\n      // only be in the case that it is a TemplateInstance), we disconnect it\n      // and remove it from this ChildPart's disconnectable children\n      notifyChildrenConnectedChanged(value as Disconnectable, false);\n      removeDisconnectableFromParent(value as Disconnectable);\n    }\n  } else {\n    notifyChildrenConnectedChanged(this, isConnected);\n  }\n}\n\n/**\n * Patches disconnection API onto ChildParts.\n */\nconst installDisconnectAPI = (obj: Disconnectable) => {\n  if ((obj as ChildPart).type == PartType.CHILD) {\n    (obj as ChildPart)._$notifyConnectionChanged ??=\n      notifyChildPartConnectedChanged;\n    (obj as ChildPart)._$reparentDisconnectables ??= reparentDisconnectables;\n  }\n};\n\n/**\n * An abstract `Directive` base class whose `disconnected` method will be\n * called when the part containing the directive is cleared as a result of\n * re-rendering, or when the user calls `part.setConnected(false)` on\n * a part that was previously rendered containing the directive (as happens\n * when e.g. a LitElement disconnects from the DOM).\n *\n * If `part.setConnected(true)` is subsequently called on a\n * containing part, the directive's `reconnected` method will be called prior\n * to its next `update`/`render` callbacks. When implementing `disconnected`,\n * `reconnected` should also be implemented to be compatible with reconnection.\n *\n * Note that updates may occur while the directive is disconnected. As such,\n * directives should generally check the `this.isConnected` flag during\n * render/update to determine whether it is safe to subscribe to resources\n * that may prevent garbage collection.\n */\nexport abstract class AsyncDirective extends Directive {\n  // As opposed to other Disconnectables, AsyncDirectives always get notified\n  // when the RootPart connection changes, so the public `isConnected`\n  // is a locally stored variable initialized via its part's getter and synced\n  // via `_$notifyDirectiveConnectionChanged`. This is cheaper than using\n  // the _$isConnected getter, which has to look back up the tree each time.\n  /**\n   * The connection state for this Directive.\n   */\n  isConnected!: boolean;\n\n  // @internal\n  override _$disconnectableChildren?: Set<Disconnectable> = undefined;\n  /**\n   * Initialize the part with internal fields\n   * @param part\n   * @param parent\n   * @param attributeIndex\n   */\n  override _$initialize(\n    part: Part,\n    parent: Disconnectable,\n    attributeIndex: number | undefined\n  ) {\n    super._$initialize(part, parent, attributeIndex);\n    addDisconnectableToParent(this);\n    this.isConnected = part._$isConnected;\n  }\n  // This property needs to remain unminified.\n  /**\n   * Called from the core code when a directive is going away from a part (in\n   * which case `shouldRemoveFromParent` should be true), and from the\n   * `setChildrenConnected` helper function when recursively changing the\n   * connection state of a tree (in which case `shouldRemoveFromParent` should\n   * be false).\n   *\n   * @param isConnected\n   * @param isClearingDirective - True when the directive itself is being\n   *     removed; false when the tree is being disconnected\n   * @internal\n   */\n  override ['_$notifyDirectiveConnectionChanged'](\n    isConnected: boolean,\n    isClearingDirective = true\n  ) {\n    if (isConnected !== this.isConnected) {\n      this.isConnected = isConnected;\n      if (isConnected) {\n        this.reconnected?.();\n      } else {\n        this.disconnected?.();\n      }\n    }\n    if (isClearingDirective) {\n      notifyChildrenConnectedChanged(this, isConnected);\n      removeDisconnectableFromParent(this);\n    }\n  }\n\n  /**\n   * Sets the value of the directive's Part outside the normal `update`/`render`\n   * lifecycle of a directive.\n   *\n   * This method should not be called synchronously from a directive's `update`\n   * or `render`.\n   *\n   * @param directive The directive to update\n   * @param value The value to set\n   */\n  setValue(value: unknown) {\n    if (isSingleExpression(this.__part as unknown as PartInfo)) {\n      this.__part._$setValue(value, this);\n    } else {\n      // this.__attributeIndex will be defined in this case, but\n      // assert it in dev mode\n      if (DEV_MODE && this.__attributeIndex === undefined) {\n        throw new Error(`Expected this.__attributeIndex to be a number`);\n      }\n      const newValues = [...(this.__part._$committedValue as Array<unknown>)];\n      newValues[this.__attributeIndex!] = value;\n      (this.__part as AttributePart)._$setValue(newValues, this, 0);\n    }\n  }\n\n  /**\n   * User callbacks for implementing logic to release any resources/subscriptions\n   * that may have been retained by this directive. Since directives may also be\n   * re-connected, `reconnected` should also be implemented to restore the\n   * working state of the directive prior to the next render.\n   */\n  protected disconnected() {}\n  protected reconnected() {}\n}\n"],"names":["notifyChildrenConnectedChanged","parent","isConnected","children","_$disconnectableChildren","undefined","obj","removeDisconnectableFromParent","_$parent","delete","size","addDisconnectableToParent","Set","has","add","installDisconnectAPI","reparentDisconnectables","newParent","this","notifyChildPartConnectedChanged","isClearingValue","fromPartIndex","value","_$committedValue","Array","isArray","i","length","type","PartType","CHILD","_$notifyConnectionChanged","_$reparentDisconnectables","AsyncDirective","Directive","constructor","_$initialize","part","attributeIndex","super","_$isConnected","_$AO","isClearingDirective","reconnected","disconnected","setValue","isSingleExpression","__part","_$setValue","newValues","__attributeIndex"],"mappings":";;;;;GAsIA,MAAMA,EAAiC,CACrCC,EACAC,aAEA,MAAMC,EAAWF,EAAOG,KACxB,QAAiBC,IAAbF,EACF,OAAO,EAET,IAAK,MAAMG,KAAOH,eASfG,GAA2D,4BAC1DJ,GACA,GAGFF,EAA+BM,EAAKJ,GAEtC,OAAO,GASHK,EAAkCD,IACtC,IAAIL,EAAQE,EACZ,EAAG,CACD,QAAgCE,KAA3BJ,EAASK,EAAIE,MAChB,MAEFL,EAAWF,EAAOG,KAClBD,EAASM,OAAOH,GAChBA,EAAML,QACoB,KAAnBE,MAAAA,SAAAA,EAAUO,QAGfC,EAA6BL,IAGjC,IAAK,IAAIL,EAASA,EAASK,EAAIE,KAAWF,EAAML,EAAQ,CACtD,IAAIE,EAAWF,EAAOG,KACtB,QAAiBC,IAAbF,EACFF,EAAOG,KAA2BD,EAAW,IAAIS,SAC5C,GAAIT,EAASU,IAAIP,GAGtB,MAEFH,EAASW,IAAIR,GACbS,EAAqBd,KAWzB,SAASe,EAAyCC,QACVZ,IAAlCa,KAAKd,MACPG,EAA+BW,MAC/BA,KAAKV,KAAWS,EAChBN,EAA0BO,OAE1BA,KAAKV,KAAWS,EAyBpB,SAASE,EAEPjB,EACAkB,GAAkB,EAClBC,EAAgB,GAEhB,MAAMC,EAAQJ,KAAKK,KACbpB,EAAWe,KAAKd,KACtB,QAAiBC,IAAbF,GAA4C,IAAlBA,EAASO,KAGvC,GAAIU,EACF,GAAII,MAAMC,QAAQH,GAIhB,IAAK,IAAII,EAAIL,EAAeK,EAAIJ,EAAMK,OAAQD,IAC5C1B,EAA+BsB,EAAMI,IAAI,GACzCnB,EAA+Be,EAAMI,SAErB,MAATJ,IAITtB,EAA+BsB,GAAyB,GACxDf,EAA+Be,SAGjCtB,EAA+BkB,KAAMhB,GAOzC,MAAMa,EAAwBT,gBACvBA,EAAkBsB,MAAQC,EAASC,qBACrCxB,GAAkByB,sBAAAA,KACjBZ,gBACDb,GAAkB0B,sBAAAA,KAA8BhB,WAqB/BiB,UAAuBC,EAA7CC,kCAYWjB,eAAiDb,EAOjD+B,KACPC,EACApC,EACAqC,GAEAC,MAAMH,KAAaC,EAAMpC,EAAQqC,GACjC3B,EAA0BO,MAC1BA,KAAKhB,YAAcmC,EAAKG,KAejBC,KACPvC,EACAwC,GAAsB,WAElBxC,IAAgBgB,KAAKhB,cACvBgB,KAAKhB,YAAcA,EACfA,YACFgB,KAAKyB,iCAALzB,gBAEAA,KAAK0B,kCAAL1B,OAGAwB,IACF1C,EAA+BkB,KAAMhB,GACrCK,EAA+BW,OAcnC2B,SAASvB,GACP,GAAIwB,EAAmB5B,KAAK6B,MAC1B7B,KAAK6B,KAAOC,KAAW1B,EAAOJ,UACzB,CAML,MAAM+B,EAAY,IAAK/B,KAAK6B,KAAOxB,MACnC0B,EAAU/B,KAAKgC,MAAqB5B,EACnCJ,KAAK6B,KAAyBC,KAAWC,EAAW/B,KAAM,IAUrD0B,gBACAD"}

package/front_end/third_party/lit-html/package/development/async-directive.d.ts

@@ -25,13 +25,14 @@
  * 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
- * disconnect (or reconnect) a tree, the `_$setChildPartConnected` 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 `_$setDirectiveConnected` on any
- * directives that are encountered in that tree, running the required callbacks.
+ * `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:
  *
@@ -87,7 +88,7 @@
  * 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
- * `_$setChildPartConnected()`, we don't iterate all of the
+ * `_$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
@@ -109,32 +110,37 @@
  *
  * Example 3: If the LitElement containing the entire tree above becomes
  * disconnected, it will run `childPart.setConnected()` (which calls
- * `childPart._$setChildPartConnected()` if it exists); in this case, we
+ * `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 { Directive } from './directive.js';
 import { Disconnectable, Part } from './lit-html.js';
-
+import { Directive } from './directive.js';
 export { directive } from './directive.js';
-
 /**
  * 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.setDirectiveConnection(false)` on
- * a part that was previously rendered containing the directive.
+ * 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.setDirectiveConnection(true)` is subsequently called on a
+ * 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;
-    private _pendingValue;
-    _$disconnetableChildren?: Set<Disconnectable>;
     /**
      * Initialize the part with internal fields
      * @param part
@@ -142,40 +148,6 @@ export declare abstract class AsyncDirective extends Directive {
      * @param attributeIndex
      */
     _$initialize(part: Part, parent: Disconnectable, attributeIndex: number | undefined): void;
-    /**
-     * Called from the core code when a directive is going away from a part (in
-     * which case `shouldRemoveFromParent` should be true), and from the
-     * `setChildrenConnected` helper function when recursively changing the
-     * connection state of a tree (in which case `shouldRemoveFromParent` should
-     * be false).
-     *
-     * @param isConnected
-     * @param isClearingDirective - True when the directive itself is being
-     *     removed; false when the tree is being disconnected
-     * @internal
-     */
-    _$setDirectiveConnected(isConnected: boolean, isClearingDirective?: boolean): void;
-    /**
-     * Private method used to set the connection state of the directive and call
-     * the respective `disconnected` or `reconnected` callback. Note thatsince
-     * `isConnected` defaults to true, we do not run `reconnected` on first
-     * render.
-     *
-     * If a call to `setValue` was made while disconnected, flush it to the part
-     * before reconnecting.
-     *
-     * @param isConnected
-     * @internal
-     */
-    private _setConnected;
-    /**
-     * Override of the base `_resolve` method to ensure `reconnected` is run
-     * prior to the next render.
-     *
-     * @override
-     * @internal
-     */
-    _$resolve(part: Part, props: Array<unknown>): unknown;
     /**
      * Sets the value of the directive's Part outside the normal `update`/`render`
      * lifecycle of a directive.
@@ -183,9 +155,6 @@ export declare abstract class AsyncDirective extends Directive {
      * This method should not be called synchronously from a directive's `update`
      * or `render`.
      *
-     * If the method is called while the part is disconnected, the value will be
-     * queued until directive is reconnected.
-     *
      * @param directive The directive to update
      * @param value The value to set
      */

package/front_end/third_party/lit-html/package/development/async-directive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-directive.d.ts","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+GG;AAEH,OAAO,EAGL,cAAc,EAEd,IAAI,EACL,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,SAAS,EAAqB,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAqJzC;;;;;;;;;;GAUG;AACH,8BAAsB,cAAe,SAAQ,SAAS;IACpD,WAAW,UAAQ;IACnB,OAAO,CAAC,aAAa,CAAqB;IAE1C,uBAAuB,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAa;IAC1D;;;;;OAKG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS;IAKpC;;;;;;;;;;;OAWG;IACH,uBAAuB,CAAC,WAAW,EAAE,OAAO,EAAE,mBAAmB,UAAO;IAOxE;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAgBrB;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO;IAUrD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO;IAmBvB;;;;;OAKG;IACH,SAAS,CAAC,YAAY;IACtB,SAAS,CAAC,WAAW;CACtB"}
+{"version":3,"file":"async-directive.d.ts","sourceRoot":"","sources":["../src/async-directive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AAEH,OAAO,EAA2B,cAAc,EAAE,IAAI,EAAC,MAAM,eAAe,CAAC;AAE7E,OAAO,EAAC,SAAS,EAAqB,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AA0JzC;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,cAAe,SAAQ,SAAS;IAMpD;;OAEG;IACH,WAAW,EAAG,OAAO,CAAC;IAItB;;;;;OAKG;IACM,YAAY,CACnB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS;IAqCpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO;IAevB;;;;;OAKG;IACH,SAAS,CAAC,YAAY;IACtB,SAAS,CAAC,WAAW;CACtB"}