ruby2js 4.0.3 → 4.0.4

data/lib/tasks/testrails/node_modules/lit-html/src/directives/style-map.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright (c) 2018 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 {AttributePart, directive, Part, PropertyPart} from '../lit-html.js';
+
+export interface StyleInfo {
+  readonly [name: string]: string;
+}
+
+/**
+ * Stores the StyleInfo object applied to a given AttributePart.
+ * Used to unset existing values when a new StyleInfo object is applied.
+ */
+const previousStylePropertyCache = new WeakMap<AttributePart, Set<string>>();
+
+/**
+ * A directive that applies CSS properties to an element.
+ *
+ * `styleMap` can only be used in the `style` attribute and must be the only
+ * expression in the attribute. It takes the property names in the `styleInfo`
+ * object and adds the property values as CSS properties. Property names with
+ * dashes (`-`) are assumed to be valid CSS property names and set on the
+ * element's style object using `setProperty()`. Names without dashes are
+ * assumed to be camelCased JavaScript property names and set on the element's
+ * style object using property assignment, allowing the style object to
+ * translate JavaScript-style names to CSS property names.
+ *
+ * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size':
+ * '0'})` sets the `background-color`, `border-top` and `--size` properties.
+ *
+ * @param styleInfo {StyleInfo}
+ */
+export const styleMap = directive((styleInfo: StyleInfo) => (part: Part) => {
+  if (!(part instanceof AttributePart) || (part instanceof PropertyPart) ||
+      part.committer.name !== 'style' || part.committer.parts.length > 1) {
+    throw new Error(
+        'The `styleMap` directive must be used in the style attribute ' +
+        'and must be the only part in the attribute.');
+  }
+
+  const {committer} = part;
+  const {style} = committer.element as HTMLElement;
+
+  let previousStyleProperties = previousStylePropertyCache.get(part);
+
+  if (previousStyleProperties === undefined) {
+    // Write static styles once
+    style.cssText = committer.strings.join(' ');
+    previousStylePropertyCache.set(part, previousStyleProperties = new Set());
+  }
+
+  // Remove old properties that no longer exist in styleInfo
+  // We use forEach() instead of for-of so that re don't require down-level
+  // iteration.
+  previousStyleProperties.forEach((name) => {
+    if (!(name in styleInfo)) {
+      previousStyleProperties!.delete(name);
+      if (name.indexOf('-') === -1) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (style as any)[name] = null;
+      } else {
+        style.removeProperty(name);
+      }
+    }
+  });
+
+  // Add or update properties
+  for (const name in styleInfo) {
+    previousStyleProperties.add(name);
+    if (name.indexOf('-') === -1) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (style as any)[name] = styleInfo[name];
+    } else {
+      style.setProperty(name, styleInfo[name]);
+    }
+  }
+});

data/lib/tasks/testrails/node_modules/lit-html/src/directives/template-content.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright (c) 2020 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 {directive, NodePart, Part} from '../lit-html.js';
+
+interface PreviousValue {
+  readonly template: HTMLTemplateElement;
+  readonly fragment: DocumentFragment;
+}
+
+// For each part, remember the value that was last rendered to the part by the
+// templateContent directive, and the DocumentFragment that was last set as a
+// value. The DocumentFragment is used as a unique key to check if the last
+// value rendered to the part was with templateContent. If not, we'll always
+// re-render the value passed to templateContent.
+const previousValues = new WeakMap<NodePart, PreviousValue>();
+
+/**
+ * Renders the content of a template element as HTML.
+ *
+ * Note, the template should be developer controlled and not user controlled.
+ * Rendering a user-controlled template with this directive
+ * could lead to cross-site-scripting vulnerabilities.
+ */
+export const templateContent =
+    directive((template: HTMLTemplateElement) => (part: Part): void => {
+      if (!(part instanceof NodePart)) {
+        throw new Error('templateContent can only be used in text bindings');
+      }
+
+      const previousValue = previousValues.get(part);
+
+      if (previousValue !== undefined && template === previousValue.template &&
+          part.value === previousValue.fragment) {
+        return;
+      }
+
+      const fragment = document.importNode(template.content, true);
+      part.setValue(fragment);
+      previousValues.set(part, {template, fragment});
+    });

data/lib/tasks/testrails/node_modules/lit-html/src/directives/unsafe-html.ts

@@ -0,0 +1,54 @@
+/**
+ * @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 {isPrimitive} from '../lib/parts.js';
+import {directive, NodePart, Part} from '../lit-html.js';
+
+interface PreviousValue {
+  readonly value: unknown;
+  readonly fragment: DocumentFragment;
+}
+
+// For each part, remember the value that was last rendered to the part by the
+// unsafeHTML directive, and the DocumentFragment that was last set as a value.
+// The DocumentFragment is used as a unique key to check if the last value
+// rendered to the part was with unsafeHTML. If not, we'll always re-render the
+// value passed to unsafeHTML.
+const previousValues = new WeakMap<NodePart, PreviousValue>();
+
+/**
+ * Renders the result as HTML, rather than text.
+ *
+ * Note, this is unsafe to use with any user-provided input that hasn't been
+ * sanitized or escaped, as it may lead to cross-site-scripting
+ * vulnerabilities.
+ */
+export const unsafeHTML = directive((value: unknown) => (part: Part): void => {
+  if (!(part instanceof NodePart)) {
+    throw new Error('unsafeHTML can only be used in text bindings');
+  }
+
+  const previousValue = previousValues.get(part);
+
+  if (previousValue !== undefined && isPrimitive(value) &&
+      value === previousValue.value && part.value === previousValue.fragment) {
+    return;
+  }
+
+  const template = document.createElement('template');
+  template.innerHTML = value as string;  // innerHTML casts to string internally
+  const fragment = document.importNode(template.content, true);
+  part.setValue(fragment);
+  previousValues.set(part, {value, fragment});
+});

data/lib/tasks/testrails/node_modules/lit-html/src/directives/unsafe-svg.ts

@@ -0,0 +1,71 @@
+/**
+ * @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 {reparentNodes} from '../lib/dom.js';
+import {isPrimitive} from '../lib/parts.js';
+import {directive, NodePart, Part} from '../lit-html.js';
+
+interface PreviousValue {
+  readonly value: unknown;
+  readonly fragment: DocumentFragment;
+}
+
+// For each part, remember the value that was last rendered to the part by the
+// unsafeSVG directive, and the DocumentFragment that was last set as a value.
+// The DocumentFragment is used as a unique key to check if the last value
+// rendered to the part was with unsafeSVG. If not, we'll always re-render the
+// value passed to unsafeSVG.
+const previousValues = new WeakMap<NodePart, PreviousValue>();
+
+const isIe = window.navigator.userAgent.indexOf('Trident/') > 0;
+
+/**
+ * Renders the result as SVG, rather than text.
+ *
+ * Note, this is unsafe to use with any user-provided input that hasn't been
+ * sanitized or escaped, as it may lead to cross-site-scripting
+ * vulnerabilities.
+ */
+export const unsafeSVG = directive((value: unknown) => (part: Part): void => {
+  if (!(part instanceof NodePart)) {
+    throw new Error('unsafeSVG can only be used in text bindings');
+  }
+
+  const previousValue = previousValues.get(part);
+
+  if (previousValue !== undefined && isPrimitive(value) &&
+      value === previousValue.value && part.value === previousValue.fragment) {
+    return;
+  }
+
+  const template = document.createElement('template');
+  const content = template.content;
+  let svgElement;
+  if (isIe) {
+    // IE can't set innerHTML of an svg element. However, it also doesn't
+    // support Trusted Types, so it's ok for us to use a string when setting
+    // innerHTML.
+    template.innerHTML = `<svg>${value}</svg>`;
+    svgElement = content.firstChild!;
+  } else {
+    svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    content.appendChild(svgElement);
+    svgElement.innerHTML = value as string;
+  }
+  content.removeChild(svgElement);
+  reparentNodes(content, svgElement.firstChild);
+  const fragment = document.importNode(content, true);
+  part.setValue(fragment);
+  previousValues.set(part, {value, fragment});
+});

data/lib/tasks/testrails/node_modules/lit-html/src/directives/until.ts

@@ -0,0 +1,104 @@
+/**
+ * @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 {isPrimitive} from '../lib/parts.js';
+import {directive, Part} from '../lit-html.js';
+
+interface AsyncState {
+  /**
+   * The last rendered index of a call to until(). A value only renders if its
+   * index is less than the `lastRenderedIndex`.
+   */
+  lastRenderedIndex: number;
+
+  values: unknown[];
+}
+
+const _state = new WeakMap<Part, AsyncState>();
+// Effectively infinity, but a SMI.
+const _infinity = 0x7fffffff;
+
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ *     const content = fetch('./content.txt').then(r => r.text());
+ *     html`${until(content, html`<span>Loading...</span>`)}`
+ */
+export const until = directive((...args: unknown[]) => (part: Part) => {
+  let state = _state.get(part)!;
+  if (state === undefined) {
+    state = {
+      lastRenderedIndex: _infinity,
+      values: [],
+    };
+    _state.set(part, state);
+  }
+  const previousValues = state.values;
+  let previousLength = previousValues.length;
+  state.values = args;
+
+  for (let i = 0; i < args.length; i++) {
+    // If we've rendered a higher-priority value already, stop.
+    if (i > state.lastRenderedIndex) {
+      break;
+    }
+
+    const value = args[i];
+
+    // Render non-Promise values immediately
+    if (isPrimitive(value) ||
+        typeof (value as {then?: unknown}).then !== 'function') {
+      part.setValue(value);
+      state.lastRenderedIndex = i;
+      // Since a lower-priority value will never overwrite a higher-priority
+      // synchronous value, we can stop processing now.
+      break;
+    }
+
+    // If this is a Promise we've already handled, skip it.
+    if (i < previousLength && value === previousValues[i]) {
+      continue;
+    }
+
+    // We have a Promise that we haven't seen before, so priorities may have
+    // changed. Forget what we rendered before.
+    state.lastRenderedIndex = _infinity;
+    previousLength = 0;
+
+    Promise.resolve(value).then((resolvedValue: unknown) => {
+      const index = state.values.indexOf(value);
+      // If state.values doesn't contain the value, we've re-rendered without
+      // the value, so don't render it. Then, only render if the value is
+      // higher-priority than what's already been rendered.
+      if (index > -1 && index < state.lastRenderedIndex) {
+        state.lastRenderedIndex = index;
+        part.setValue(resolvedValue);
+        part.commit();
+      }
+    });
+  }
+});

data/lib/tasks/testrails/node_modules/lit-html/src/env.d.ts

@@ -0,0 +1,20 @@
+interface ShadyCSS {
+  nativeCss: boolean;
+  nativeShadow: boolean;
+  styleElement(host: Element, overrideProps?: {[key: string]: string}): void;
+  prepareTemplateDom(template: Element, elementName: string): void;
+  prepareTemplateStyles(
+      template: Element, elementName: string, typeExtension?: string): void;
+  ScopingShim: undefined|{
+    prepareAdoptedCssText(cssTextArray: string[], elementName: string): void;
+  };
+}
+
+interface ShadyDOM {
+  inUse: boolean;
+}
+
+interface Window {
+  ShadyCSS?: ShadyCSS;
+  ShadyDOM?: ShadyDOM;
+}

data/lib/tasks/testrails/node_modules/lit-html/src/lib/default-template-processor.ts

@@ -0,0 +1,59 @@
+/**
+ * @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 {Part} from './part.js';
+import {AttributeCommitter, BooleanAttributePart, EventPart, NodePart, PropertyCommitter} from './parts.js';
+import {RenderOptions} from './render-options.js';
+import {TemplateProcessor} from './template-processor.js';
+
+/**
+ * Creates Parts when a template is instantiated.
+ */
+export class DefaultTemplateProcessor implements TemplateProcessor {
+  /**
+   * Create parts for an attribute-position binding, given the event, attribute
+   * name, and string literals.
+   *
+   * @param element The element containing the binding
+   * @param name  The attribute name
+   * @param strings The string literals. There are always at least two strings,
+   *   event for fully-controlled bindings with a single expression.
+   */
+  handleAttributeExpressions(
+      element: Element, name: string, strings: string[],
+      options: RenderOptions): ReadonlyArray<Part> {
+    const prefix = name[0];
+    if (prefix === '.') {
+      const committer = new PropertyCommitter(element, name.slice(1), strings);
+      return committer.parts;
+    }
+    if (prefix === '@') {
+      return [new EventPart(element, name.slice(1), options.eventContext)];
+    }
+    if (prefix === '?') {
+      return [new BooleanAttributePart(element, name.slice(1), strings)];
+    }
+    const committer = new AttributeCommitter(element, name, strings);
+    return committer.parts;
+  }
+  /**
+   * Create parts for a text-position binding.
+   * @param templateFactory
+   */
+  handleTextExpression(options: RenderOptions) {
+    return new NodePart(options);
+  }
+}
+
+export const defaultTemplateProcessor = new DefaultTemplateProcessor();