chrome-devtools-frontend 1.0.1506453 → 1.0.1510180

package/extensions/cxx_debugging/third_party/lit-html/src/lib/shady-render.ts

@@ -1,316 +0,0 @@
-/**
- * @license
- * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
- * This code may only be used under the BSD style license found at
- * http://polymer.github.io/LICENSE.txt
- * The complete set of authors may be found at
- * http://polymer.github.io/AUTHORS.txt
- * The complete set of contributors may be found at
- * http://polymer.github.io/CONTRIBUTORS.txt
- * Code distributed by Google as part of the polymer project is also
- * subject to an additional IP rights grant found at
- * http://polymer.github.io/PATENTS.txt
- */
-
-/**
- * Module to add shady DOM/shady CSS polyfill support to lit-html template
- * rendering. See the [[render]] method for details.
- *
- * @packageDocumentation
- */
-
-/**
- * Do not remove this comment; it keeps typedoc from misplacing the module
- * docs.
- */
-import {removeNodes} from './dom.js';
-import {insertNodeIntoTemplate, removeNodesFromTemplate} from './modify-template.js';
-import {RenderOptions} from './render-options.js';
-import {parts, render as litRender} from './render.js';
-import {templateCaches} from './template-factory.js';
-import {TemplateInstance} from './template-instance.js';
-import {TemplateResult} from './template-result.js';
-import {marker, Template} from './template.js';
-
-export {html, svg, TemplateResult} from '../lit-html.js';
-
-// Get a key to lookup in `templateCaches`.
-const getTemplateCacheKey = (type: string, scopeName: string) =>
-    `${type}--${scopeName}`;
-
-let compatibleShadyCSSVersion = true;
-
-if (typeof window.ShadyCSS === 'undefined') {
-  compatibleShadyCSSVersion = false;
-} else if (typeof window.ShadyCSS.prepareTemplateDom === 'undefined') {
-  console.warn(
-      `Incompatible ShadyCSS version detected. ` +
-      `Please update to at least @webcomponents/webcomponentsjs@2.0.2 and ` +
-      `@webcomponents/shadycss@1.3.1.`);
-  compatibleShadyCSSVersion = false;
-}
-
-/**
- * Template factory which scopes template DOM using ShadyCSS.
- * @param scopeName {string}
- */
-export const shadyTemplateFactory = (scopeName: string) =>
-    (result: TemplateResult) => {
-      const cacheKey = getTemplateCacheKey(result.type, scopeName);
-      let templateCache = templateCaches.get(cacheKey);
-      if (templateCache === undefined) {
-        templateCache = {
-          stringsArray: new WeakMap<TemplateStringsArray, Template>(),
-          keyString: new Map<string, Template>()
-        };
-        templateCaches.set(cacheKey, templateCache);
-      }
-
-      let template = templateCache.stringsArray.get(result.strings);
-      if (template !== undefined) {
-        return template;
-      }
-
-      const key = result.strings.join(marker);
-      template = templateCache.keyString.get(key);
-      if (template === undefined) {
-        const element = result.getTemplateElement();
-        if (compatibleShadyCSSVersion) {
-          window.ShadyCSS!.prepareTemplateDom(element, scopeName);
-        }
-        template = new Template(result, element);
-        templateCache.keyString.set(key, template);
-      }
-      templateCache.stringsArray.set(result.strings, template);
-      return template;
-    };
-
-const TEMPLATE_TYPES = ['html', 'svg'];
-
-/**
- * Removes all style elements from Templates for the given scopeName.
- */
-const removeStylesFromLitTemplates = (scopeName: string) => {
-  TEMPLATE_TYPES.forEach((type) => {
-    const templates = templateCaches.get(getTemplateCacheKey(type, scopeName));
-    if (templates !== undefined) {
-      templates.keyString.forEach((template) => {
-        const {element: {content}} = template;
-        // IE 11 doesn't support the iterable param Set constructor
-        const styles = new Set<Element>();
-        Array.from(content.querySelectorAll('style')).forEach((s: Element) => {
-          styles.add(s);
-        });
-        removeNodesFromTemplate(template, styles);
-      });
-    }
-  });
-};
-
-const shadyRenderSet = new Set<string>();
-
-/**
- * For the given scope name, ensures that ShadyCSS style scoping is performed.
- * This is done just once per scope name so the fragment and template cannot
- * be modified.
- * (1) extracts styles from the rendered fragment and hands them to ShadyCSS
- * to be scoped and appended to the document
- * (2) removes style elements from all lit-html Templates for this scope name.
- *
- * Note, <style> elements can only be placed into templates for the
- * initial rendering of the scope. If <style> elements are included in templates
- * dynamically rendered to the scope (after the first scope render), they will
- * not be scoped and the <style> will be left in the template and rendered
- * output.
- */
-const prepareTemplateStyles =
-    (scopeName: string, renderedDOM: DocumentFragment, template?: Template) => {
-      shadyRenderSet.add(scopeName);
-      // If `renderedDOM` is stamped from a Template, then we need to edit that
-      // Template's underlying template element. Otherwise, we create one here
-      // to give to ShadyCSS, which still requires one while scoping.
-      const templateElement =
-          !!template ? template.element : document.createElement('template');
-      // Move styles out of rendered DOM and store.
-      const styles = renderedDOM.querySelectorAll('style');
-      const {length} = styles;
-      // If there are no styles, skip unnecessary work
-      if (length === 0) {
-        // Ensure prepareTemplateStyles is called to support adding
-        // styles via `prepareAdoptedCssText` since that requires that
-        // `prepareTemplateStyles` is called.
-        //
-        // ShadyCSS will only update styles containing @apply in the template
-        // given to `prepareTemplateStyles`. If no lit Template was given,
-        // ShadyCSS will not be able to update uses of @apply in any relevant
-        // template. However, this is not a problem because we only create the
-        // template for the purpose of supporting `prepareAdoptedCssText`,
-        // which doesn't support @apply at all.
-        window.ShadyCSS!.prepareTemplateStyles(templateElement, scopeName);
-        return;
-      }
-      const condensedStyle = document.createElement('style');
-      // Collect styles into a single style. This helps us make sure ShadyCSS
-      // manipulations will not prevent us from being able to fix up template
-      // part indices.
-      // NOTE: collecting styles is inefficient for browsers but ShadyCSS
-      // currently does this anyway. When it does not, this should be changed.
-      for (let i = 0; i < length; i++) {
-        const style = styles[i];
-        style.parentNode!.removeChild(style);
-        condensedStyle.textContent! += style.textContent;
-      }
-      // Remove styles from nested templates in this scope.
-      removeStylesFromLitTemplates(scopeName);
-      // And then put the condensed style into the "root" template passed in as
-      // `template`.
-      const content = templateElement.content;
-      if (!!template) {
-        insertNodeIntoTemplate(template, condensedStyle, content.firstChild);
-      } else {
-        content.insertBefore(condensedStyle, content.firstChild);
-      }
-      // Note, it's important that ShadyCSS gets the template that `lit-html`
-      // will actually render so that it can update the style inside when
-      // needed (e.g. @apply native Shadow DOM case).
-      window.ShadyCSS!.prepareTemplateStyles(templateElement, scopeName);
-      const style = content.querySelector('style');
-      if (window.ShadyCSS!.nativeShadow && style !== null) {
-        // When in native Shadow DOM, ensure the style created by ShadyCSS is
-        // included in initially rendered output (`renderedDOM`).
-        renderedDOM.insertBefore(style.cloneNode(true), renderedDOM.firstChild);
-      } else if (!!template) {
-        // When no style is left in the template, parts will be broken as a
-        // result. To fix this, we put back the style node ShadyCSS removed
-        // and then tell lit to remove that node from the template.
-        // There can be no style in the template in 2 cases (1) when Shady DOM
-        // is in use, ShadyCSS removes all styles, (2) when native Shadow DOM
-        // is in use ShadyCSS removes the style if it contains no content.
-        // NOTE, ShadyCSS creates its own style so we can safely add/remove
-        // `condensedStyle` here.
-        content.insertBefore(condensedStyle, content.firstChild);
-        const removes = new Set<Node>();
-        removes.add(condensedStyle);
-        removeNodesFromTemplate(template, removes);
-      }
-    };
-
-export interface ShadyRenderOptions extends Partial<RenderOptions> {
-  scopeName: string;
-}
-
-/**
- * Extension to the standard `render` method which supports rendering
- * to ShadowRoots when the ShadyDOM (https://github.com/webcomponents/shadydom)
- * and ShadyCSS (https://github.com/webcomponents/shadycss) polyfills are used
- * or when the webcomponentsjs
- * (https://github.com/webcomponents/webcomponentsjs) polyfill is used.
- *
- * Adds a `scopeName` option which is used to scope element DOM and stylesheets
- * when native ShadowDOM is unavailable. The `scopeName` will be added to
- * the class attribute of all rendered DOM. In addition, any style elements will
- * be automatically re-written with this `scopeName` selector and moved out
- * of the rendered DOM and into the document `<head>`.
- *
- * It is common to use this render method in conjunction with a custom element
- * which renders a shadowRoot. When this is done, typically the element's
- * `localName` should be used as the `scopeName`.
- *
- * In addition to DOM scoping, ShadyCSS also supports a basic shim for css
- * custom properties (needed only on older browsers like IE11) and a shim for
- * a deprecated feature called `@apply` that supports applying a set of css
- * custom properties to a given location.
- *
- * Usage considerations:
- *
- * * Part values in `<style>` elements are only applied the first time a given
- * `scopeName` renders. Subsequent changes to parts in style elements will have
- * no effect. Because of this, parts in style elements should only be used for
- * values that will never change, for example parts that set scope-wide theme
- * values or parts which render shared style elements.
- *
- * * Note, due to a limitation of the ShadyDOM polyfill, rendering in a
- * custom element's `constructor` is not supported. Instead rendering should
- * either done asynchronously, for example at microtask timing (for example
- * `Promise.resolve()`), or be deferred until the first time the element's
- * `connectedCallback` runs.
- *
- * Usage considerations when using shimmed custom properties or `@apply`:
- *
- * * Whenever any dynamic changes are made which affect
- * css custom properties, `ShadyCSS.styleElement(element)` must be called
- * to update the element. There are two cases when this is needed:
- * (1) the element is connected to a new parent, (2) a class is added to the
- * element that causes it to match different custom properties.
- * To address the first case when rendering a custom element, `styleElement`
- * should be called in the element's `connectedCallback`.
- *
- * * Shimmed custom properties may only be defined either for an entire
- * shadowRoot (for example, in a `:host` rule) or via a rule that directly
- * matches an element with a shadowRoot. In other words, instead of flowing from
- * parent to child as do native css custom properties, shimmed custom properties
- * flow only from shadowRoots to nested shadowRoots.
- *
- * * When using `@apply` mixing css shorthand property names with
- * non-shorthand names (for example `border` and `border-width`) is not
- * supported.
- */
-export const render =
-    (result: unknown,
-     container: Element|DocumentFragment|ShadowRoot,
-     options: ShadyRenderOptions) => {
-      if (!options || typeof options !== 'object' || !options.scopeName) {
-        throw new Error('The `scopeName` option is required.');
-      }
-      const scopeName = options.scopeName;
-      const hasRendered = parts.has(container);
-      const needsScoping = compatibleShadyCSSVersion &&
-          container.nodeType === 11 /* Node.DOCUMENT_FRAGMENT_NODE */ &&
-          !!(container as ShadowRoot).host;
-      // Handle first render to a scope specially...
-      const firstScopeRender = needsScoping && !shadyRenderSet.has(scopeName);
-      // On first scope render, render into a fragment; this cannot be a single
-      // fragment that is reused since nested renders can occur synchronously.
-      const renderContainer =
-          firstScopeRender ? document.createDocumentFragment() : container;
-      litRender(
-          result,
-          renderContainer,
-          {templateFactory: shadyTemplateFactory(scopeName), ...options} as
-              RenderOptions);
-      // When performing first scope render,
-      // (1) We've rendered into a fragment so that there's a chance to
-      // `prepareTemplateStyles` before sub-elements hit the DOM
-      // (which might cause them to render based on a common pattern of
-      // rendering in a custom element's `connectedCallback`);
-      // (2) Scope the template with ShadyCSS one time only for this scope.
-      // (3) Render the fragment into the container and make sure the
-      // container knows its `part` is the one we just rendered. This ensures
-      // DOM will be re-used on subsequent renders.
-      if (firstScopeRender) {
-        const part = parts.get(renderContainer)!;
-        parts.delete(renderContainer);
-        // ShadyCSS might have style sheets (e.g. from `prepareAdoptedCssText`)
-        // that should apply to `renderContainer` even if the rendered value is
-        // not a TemplateInstance. However, it will only insert scoped styles
-        // into the document if `prepareTemplateStyles` has already been called
-        // for the given scope name.
-        const template = part.value instanceof TemplateInstance ?
-            part.value.template :
-            undefined;
-        prepareTemplateStyles(
-            scopeName, renderContainer as DocumentFragment, template);
-        removeNodes(container, container.firstChild);
-        container.appendChild(renderContainer);
-        parts.set(container, part);
-      }
-      // After elements have hit the DOM, update styling if this is the
-      // initial render to this container.
-      // This is needed whenever dynamic changes are made so it would be
-      // safest to do every render; however, this would regress performance
-      // so we leave it up to the user to call `ShadyCSS.styleElement`
-      // for dynamic changes.
-      if (!hasRendered && needsScoping) {
-        window.ShadyCSS!.styleElement((container as ShadowRoot).host);
-      }
-    };

package/extensions/cxx_debugging/third_party/lit-html/src/lib/template-factory.ts

@@ -1,92 +0,0 @@
-/**
- * @license
- * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
- * This code may only be used under the BSD style license found at
- * http://polymer.github.io/LICENSE.txt
- * The complete set of authors may be found at
- * http://polymer.github.io/AUTHORS.txt
- * The complete set of contributors may be found at
- * http://polymer.github.io/CONTRIBUTORS.txt
- * Code distributed by Google as part of the polymer project is also
- * subject to an additional IP rights grant found at
- * http://polymer.github.io/PATENTS.txt
- */
-
-import {TemplateResult} from './template-result.js';
-import {marker, Template} from './template.js';
-
-/**
- * A function type that creates a Template from a TemplateResult.
- *
- * This is a hook into the template-creation process for rendering that
- * requires some modification of templates before they're used, like ShadyCSS,
- * which must add classes to elements and remove styles.
- *
- * Templates should be cached as aggressively as possible, so that many
- * TemplateResults produced from the same expression only do the work of
- * creating the Template the first time.
- *
- * Templates are usually cached by TemplateResult.strings and
- * TemplateResult.type, but may be cached by other keys if this function
- * modifies the template.
- *
- * Note that currently TemplateFactories must not add, remove, or reorder
- * expressions, because there is no way to describe such a modification
- * to render() so that values are interpolated to the correct place in the
- * template instances.
- */
-export type TemplateFactory = (result: TemplateResult) => Template;
-
-/**
- * The default TemplateFactory which caches Templates keyed on
- * result.type and result.strings.
- */
-export function templateFactory(result: TemplateResult) {
-  let templateCache = templateCaches.get(result.type);
-  if (templateCache === undefined) {
-    templateCache = {
-      stringsArray: new WeakMap<TemplateStringsArray, Template>(),
-      keyString: new Map<string, Template>()
-    };
-    templateCaches.set(result.type, templateCache);
-  }
-
-  let template = templateCache.stringsArray.get(result.strings);
-  if (template !== undefined) {
-    return template;
-  }
-
-  // If the TemplateStringsArray is new, generate a key from the strings
-  // This key is shared between all templates with identical content
-  const key = result.strings.join(marker);
-
-  // Check if we already have a Template for this key
-  template = templateCache.keyString.get(key);
-  if (template === undefined) {
-    // If we have not seen this key before, create a new Template
-    template = new Template(result, result.getTemplateElement());
-    // Cache the Template for this key
-    templateCache.keyString.set(key, template);
-  }
-
-  // Cache all future queries for this TemplateStringsArray
-  templateCache.stringsArray.set(result.strings, template);
-  return template;
-}
-
-/**
- * The first argument to JS template tags retain identity across multiple
- * calls to a tag for the same literal, so we can cache work done per literal
- * in a Map.
- *
- * Safari currently has a bug which occasionally breaks this behavior, so we
- * need to cache the Template at two levels. We first cache the
- * TemplateStringsArray, and if that fails, we cache a key constructed by
- * joining the strings array.
- */
-export interface TemplateCache {
-  readonly stringsArray: WeakMap<TemplateStringsArray, Template>;
-  readonly keyString: Map<string, Template>;
-}
-
-export const templateCaches = new Map<string, TemplateCache>();

package/extensions/cxx_debugging/third_party/lit-html/src/lib/template-instance.ts

@@ -1,155 +0,0 @@
-/**
- * @license
- * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
- * This code may only be used under the BSD style license found at
- * http://polymer.github.io/LICENSE.txt
- * The complete set of authors may be found at
- * http://polymer.github.io/AUTHORS.txt
- * The complete set of contributors may be found at
- * http://polymer.github.io/CONTRIBUTORS.txt
- * Code distributed by Google as part of the polymer project is also
- * subject to an additional IP rights grant found at
- * http://polymer.github.io/PATENTS.txt
- */
-
-import {isCEPolyfill} from './dom.js';
-import {Part} from './part.js';
-import {RenderOptions} from './render-options.js';
-import {TemplateProcessor} from './template-processor.js';
-import {isTemplatePartActive, Template, TemplatePart} from './template.js';
-
-/**
- * An instance of a `Template` that can be attached to the DOM and updated
- * with new values.
- */
-export class TemplateInstance {
-  private readonly __parts: Array<Part|undefined> = [];
-  readonly processor: TemplateProcessor;
-  readonly options: RenderOptions;
-  readonly template: Template;
-
-  constructor(
-      template: Template, processor: TemplateProcessor,
-      options: RenderOptions) {
-    this.template = template;
-    this.processor = processor;
-    this.options = options;
-  }
-
-  update(values: readonly unknown[]) {
-    let i = 0;
-    for (const part of this.__parts) {
-      if (part !== undefined) {
-        part.setValue(values[i]);
-      }
-      i++;
-    }
-    for (const part of this.__parts) {
-      if (part !== undefined) {
-        part.commit();
-      }
-    }
-  }
-
-  _clone(): DocumentFragment {
-    // There are a number of steps in the lifecycle of a template instance's
-    // DOM fragment:
-    //  1. Clone - create the instance fragment
-    //  2. Adopt - adopt into the main document
-    //  3. Process - find part markers and create parts
-    //  4. Upgrade - upgrade custom elements
-    //  5. Update - set node, attribute, property, etc., values
-    //  6. Connect - connect to the document. Optional and outside of this
-    //     method.
-    //
-    // We have a few constraints on the ordering of these steps:
-    //  * We need to upgrade before updating, so that property values will pass
-    //    through any property setters.
-    //  * We would like to process before upgrading so that we're sure that the
-    //    cloned fragment is inert and not disturbed by self-modifying DOM.
-    //  * We want custom elements to upgrade even in disconnected fragments.
-    //
-    // Given these constraints, with full custom elements support we would
-    // prefer the order: Clone, Process, Adopt, Upgrade, Update, Connect
-    //
-    // But Safari does not implement CustomElementRegistry#upgrade, so we
-    // can not implement that order and still have upgrade-before-update and
-    // upgrade disconnected fragments. So we instead sacrifice the
-    // process-before-upgrade constraint, since in Custom Elements v1 elements
-    // must not modify their light DOM in the constructor. We still have issues
-    // when co-existing with CEv0 elements like Polymer 1, and with polyfills
-    // that don't strictly adhere to the no-modification rule because shadow
-    // DOM, which may be created in the constructor, is emulated by being placed
-    // in the light DOM.
-    //
-    // The resulting order is on native is: Clone, Adopt, Upgrade, Process,
-    // Update, Connect. document.importNode() performs Clone, Adopt, and Upgrade
-    // in one step.
-    //
-    // The Custom Elements v1 polyfill supports upgrade(), so the order when
-    // polyfilled is the more ideal: Clone, Process, Adopt, Upgrade, Update,
-    // Connect.
-
-    const fragment = isCEPolyfill ?
-        this.template.element.content.cloneNode(true) as DocumentFragment :
-        document.importNode(this.template.element.content, true);
-
-    const stack: Node[] = [];
-    const parts = this.template.parts;
-    // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
-    const walker = document.createTreeWalker(
-        fragment,
-        133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */,
-        null,
-        false);
-    let partIndex = 0;
-    let nodeIndex = 0;
-    let part: TemplatePart;
-    let node = walker.nextNode();
-    // Loop through all the nodes and parts of a template
-    while (partIndex < parts.length) {
-      part = parts[partIndex];
-      if (!isTemplatePartActive(part)) {
-        this.__parts.push(undefined);
-        partIndex++;
-        continue;
-      }
-
-      // Progress the tree walker until we find our next part's node.
-      // Note that multiple parts may share the same node (attribute parts
-      // on a single element), so this loop may not run at all.
-      while (nodeIndex < part.index) {
-        nodeIndex++;
-        if (node!.nodeName === 'TEMPLATE') {
-          stack.push(node!);
-          walker.currentNode = (node as HTMLTemplateElement).content;
-        }
-        if ((node = walker.nextNode()) === null) {
-          // We've exhausted the content inside a nested template element.
-          // Because we still have parts (the outer for-loop), we know:
-          // - There is a template in the stack
-          // - The walker will find a nextNode outside the template
-          walker.currentNode = stack.pop()!;
-          node = walker.nextNode();
-        }
-      }
-
-      // We've arrived at our part's node.
-      if (part.type === 'node') {
-        const part = this.processor.handleTextExpression(this.options);
-        part.insertAfterNode(node!.previousSibling!);
-        this.__parts.push(part);
-      } else {
-        this.__parts.push(...this.processor.handleAttributeExpressions(
-            node as Element, part.name, part.strings, this.options));
-      }
-      partIndex++;
-    }
-
-    if (isCEPolyfill) {
-      document.adoptNode(fragment);
-      customElements.upgrade(fragment);
-    }
-    return fragment;
-  }
-}

package/extensions/cxx_debugging/third_party/lit-html/src/lib/template-processor.ts

@@ -1,51 +0,0 @@
-/**
- * @license
- * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
- * This code may only be used under the BSD style license found at
- * http://polymer.github.io/LICENSE.txt
- * The complete set of authors may be found at
- * http://polymer.github.io/AUTHORS.txt
- * The complete set of contributors may be found at
- * http://polymer.github.io/CONTRIBUTORS.txt
- * Code distributed by Google as part of the polymer project is also
- * subject to an additional IP rights grant found at
- * http://polymer.github.io/PATENTS.txt
- */
-
-/**
- * @module lit-html
- */
-
-import {Part} from './part.js';
-import {NodePart} from './parts.js';
-import {RenderOptions} from './render-options.js';
-
-export interface TemplateProcessor {
-  /**
-   * Create parts for an attribute-position binding, given the element,
-   * attribute name, and string literals.
-   *
-   * @param element The element containing the binding
-   * @param name  The attribute name, including a possible prefix. The name may
-   *   be prefixed by `.` (for a property binding), `@` (for an event binding)
-   * or
-   *   `?` (for a boolean attribute binding).
-   * @param strings The array of literal strings that form the static part of
-   *     the
-   *   attribute value. There are always at least two strings,
-   *   even for fully-controlled bindings with a single expression. For example,
-   *   for the binding `attr="${e1}-${e2}"`, the `strings` array includes three
-   *   strings (`['', '-', '']`)—the text _before_ the first expression (the
-   * empty string), the text between the two expressions (`'-'`), and the text
-   * after the last expression (another empty string).
-   */
-  handleAttributeExpressions(
-      element: Element, name: string, strings: ReadonlyArray<string>,
-      options: RenderOptions): ReadonlyArray<Part>;
-
-  /**
-   * Create parts for a text-position binding.
-   * @param partOptions
-   */
-  handleTextExpression(options: RenderOptions): NodePart;
-}