@globalpayments/vega 2.49.1 → 2.51.0

package/dist/collection/components/vega-box/slimmers/controllers/vega-box-state-styles-controller.js

@@ -57,6 +57,7 @@ export class VegaBoxStateStylesController extends VegaSlimmer {
     (_a = this.host.shadowRoot.querySelector(`style#state-styles-${flag}`)) === null || _a === void 0 ? void 0 : _a.remove();
     const styles = formatAndValidStateToken(token, flag);
     if (styles) {
+      // eslint-disable-next-line no-restricted-globals
       const styleElement = document.createElement('style');
       styleElement.setAttribute('id', `state-styles-${flag}`);
       styleElement.innerHTML = formatAndValidStateToken(token, flag);

package/dist/collection/components/vega-carousel/vega-carousel.js

@@ -234,15 +234,18 @@ export class VegaCarousel {
     const carouselItemWrapperList = [];
     const carouselContentElementArray = this.carouselContentElements;
     for (let j = 0; j < this.totalPages; j++) {
+      // eslint-disable-next-line no-restricted-globals
       const carouselItemWrapper = document.createElement('vega-grid');
       carouselItemWrapper.setAttribute('gap', this.spacing);
       carouselItemWrapper.setAttribute('column', this.currentItemsPerPage.toString());
       carouselItemWrapper.setAttribute('row', '1');
       for (let i = j * this.currentItemsPerPage; i < carouselContentElementArray.length && i < this.currentItemsPerPage * (j + 1); i++) {
+        // eslint-disable-next-line no-restricted-globals
         const divInner = document.createElement('div');
         divInner.appendChild(carouselContentElementArray[i]);
         carouselItemWrapper.appendChild(divInner);
       }
+      // eslint-disable-next-line no-restricted-globals
       const divOuter = document.createElement('div');
       divOuter.classList.add('carousel-item');
       j === 0 && divOuter.classList.add('active');

package/dist/collection/components/vega-code-block/assets/copy.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 12 12"><g clip-path="url(#clip0_70002_574)"><path fill="currentColor" d="M11.7794 1.65539L10.3439 0.219844C10.2044 0.0790078 10.0122 0 9.81303 0H5.97865C5.15014 0 4.47865 0.671719 4.47865 1.5L4.47911 7.5C4.49975 8.32969 5.1724 9 5.99975 9H10.4997C11.3247 9 11.9997 8.325 11.9997 7.5V2.18555C11.9997 1.9868 11.9201 1.79602 11.7794 1.65539ZM10.8747 7.5C10.8747 7.70709 10.7068 7.875 10.4997 7.875H5.97865C5.77151 7.875 5.60365 7.70709 5.60365 7.5V1.50305C5.60365 1.29595 5.77156 1.12805 5.97865 1.12805H8.97865L8.99975 2.25C8.99975 2.66414 9.33561 3 9.74975 3H10.8537V7.5H10.8747ZM6.37475 10.5C6.37475 10.7071 6.20684 10.875 5.99975 10.875H1.47865C1.27151 10.875 1.10365 10.7071 1.10365 10.5L1.12428 4.50234C1.12428 4.29525 1.29218 4.12734 1.49928 4.12734H3.74975V3H1.49951C0.670996 3 -0.000488281 3.67148 -0.000488281 4.5L-0.000258594 10.5C-0.000207031 11.3273 0.671465 12 1.49975 12H5.99975C6.82475 12 7.49975 11.325 7.49975 10.5V9.75H6.39584L6.37475 10.5Z"/></g><defs><clipPath id="clip0_70002_574"><rect width="12" height="12" fill="currentColor"/></clipPath></defs></svg>`,
+};

package/dist/collection/components/vega-code-block/slimmers/controllers/code-block-range.js

@@ -0,0 +1,129 @@
+/**
+ * The code block component range class.
+ */
+export class CodeBlockRange {
+  /**
+   * Initial the code block range.
+   *
+   * @param {HTMLElement} codeContainerRef - The code content container ref.
+   */
+  constructor(codeContainerRef) {
+    // The cursor position.
+    this.contentOffset = 0;
+    // The range selected text, the value will be empty if the range is collapsed.
+    this.selectedText = '';
+    this.codeContainerRef = codeContainerRef;
+  }
+  /**
+   * Update the code block range when the focus node changed or focus node content changed.
+   *
+   * @param {Node} startContainer - The focus node instance.
+   * @param {number} startOffset - The focus offset.
+   * @param {CodeNodeType[]} currentNodes - The current code node array.
+   * @param {string} [selectedText] - The range selected text.
+   * @returns {CodeBlockRange} - The new code block range instance.
+   */
+  updateRange(startContainer, startOffset, currentNodes, selectedText = '') {
+    const range = new CodeBlockRange(this.codeContainerRef);
+    range.selectedText = selectedText;
+    range.contentOffset = range.getContentOffset(startContainer, startOffset, currentNodes);
+    return range;
+  }
+  /**
+   * Update the cursor position when insert text or delete text...
+   *
+   * @param {number} newContentOffset - New value for content offset.
+   * @returns {number} - The new content offset.
+   */
+  updateContentOffset(newContentOffset) {
+    this.contentOffset = Math.max(0, newContentOffset);
+    this.selectedText = '';
+    return this.contentOffset;
+  }
+  /**
+   * Create a native range from the current code block range.
+   *
+   * @param {CodeNodeType[]} nextCodeNodes - The code block node array.
+   * @returns {Nullable<Range>} - The range instance.
+   */
+  createNativeRange(nextCodeNodes) {
+    const { nodeIndex, offset } = this.getFocusNodeState(nextCodeNodes, this.contentOffset);
+    const range = new Range();
+    const focusNode = this.codeContainerRef.querySelector(`span[data-index="${nodeIndex}"]`);
+    if (focusNode) {
+      const startOffset = Math.min(focusNode.firstChild.textContent.length, offset);
+      range.setStart(focusNode.firstChild, startOffset);
+      range.setEnd(focusNode.firstChild, startOffset);
+      return range;
+    }
+  }
+  /**
+   * Calculate the cursor position.
+   *
+   * @param {Node} startContainer - The cursor node.
+   * @param {number} startOffset - The cursor offset.
+   * @param {CodeNodeType[]} currentNodes - The code block node array.
+   * @returns {number} - A number value.
+   */
+  getContentOffset(startContainer, startOffset, currentNodes) {
+    let startSpan = startContainer.nodeType === Node.TEXT_NODE
+      ? startContainer.parentElement
+      : startContainer;
+    if (startSpan.nodeName === 'CODE' && startSpan.childNodes && startSpan.childNodes.length) {
+      startSpan = startSpan.childNodes[Math.min(startOffset, startSpan.childNodes.length - 1)];
+      startOffset = 0;
+    }
+    if (startSpan && startSpan.hasAttribute('data-index')) {
+      const index = Number(startSpan.dataset.index);
+      let beforeText = '';
+      for (let i = 0; i < index; i++) {
+        beforeText += currentNodes[i].text;
+      }
+      return beforeText.length + startOffset;
+    }
+    return 0;
+  }
+  /**
+   * Get the next focus node of the code block node array.
+   *
+   * @param {CodeNodeType[]} codeNodes - The current code block array.
+   * @param {number} contentOffset - The cursor position.
+   * @returns {FocusNodeStateType} - The object contains next focus node index and offset.
+   */
+  getFocusNodeState(codeNodes, contentOffset) {
+    const content = this.getCodeContent(codeNodes);
+    const result = { nodeIndex: 0, offset: 0 };
+    if (!content || contentOffset >= content.length) {
+      result.nodeIndex = codeNodes.length - 1;
+      result.offset = codeNodes[result.nodeIndex].text.length;
+    }
+    else {
+      let text = '';
+      for (let i = 0; i < codeNodes.length; i++) {
+        text += codeNodes[i].text;
+        if (text.length >= contentOffset) {
+          result.offset = Math.max(0, codeNodes[i].text.length - (text.length - contentOffset));
+          result.nodeIndex = i;
+          break;
+        }
+      }
+    }
+    // The cursor position is incorrect in firefox when cursor node is line break node.
+    if (codeNodes[result.nodeIndex].text === '\n' &&
+      result.offset > 0 &&
+      codeNodes[result.nodeIndex + 1]) {
+      result.nodeIndex += 1;
+      result.offset = 0;
+    }
+    return result;
+  }
+  /**
+   * Get all code content from the code block node array.
+   *
+   * @param {CodeNodeType[]} codeNodes - The code block node array.
+   * @returns {string} - The code content.
+   */
+  getCodeContent(codeNodes) {
+    return codeNodes.map((codeNode) => codeNode.text).join('');
+  }
+}

package/dist/collection/components/vega-code-block/slimmers/controllers/code-highlight-parser.abstract.js

@@ -0,0 +1,87 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
+import { CodeLanguage } from '../../types';
+const presetLanguages = Object.values(CodeLanguage);
+/**
+ * Processing the code content into different types of nodes.
+ */
+export class CodeHighlightParser extends VegaSlimmer {
+  /**
+   * Split the HTML tag to avoid the content render to a html element.
+   *
+   * @example <div> -> ['<', 'div', '>']
+   * @param {string} text - The code content.
+   * @returns {string[]} - The code content array.
+   */
+  splitTag(text) {
+    if (!this.hasSpecialCharacter(text) || text.length < 2) {
+      return [text];
+    }
+    else {
+      const result = [];
+      const textArray = text.split('');
+      let nextIndex = 0;
+      textArray.forEach((item) => {
+        if (item === '<' || item === '>' || item === '/') {
+          result.push(item);
+          nextIndex = result.length;
+        }
+        else {
+          result[nextIndex] = result[nextIndex] ? result[nextIndex] + item : item;
+        }
+      });
+      return result;
+    }
+  }
+  /**
+   * Check the current language is a preset language and the language is not plain text.
+   *
+   * @param {Nullable<string>} language - The input language.
+   * @returns {boolean} - The boolean result.
+   */
+  isHighlightLanguage(language) {
+    return language !== 'plainText' && presetLanguages.includes(language);
+  }
+  /**
+   * Mark the line number class for the first node of each line.
+   *
+   * @param {CodeNodeType[]} codeNodes - The code nodes array.
+   * @returns {CodeNodeType[]} - The code node array with line number tag.
+   */
+  markLineNumberNodes(codeNodes) {
+    if (codeNodes.length === 0) {
+      codeNodes.push({ text: '\n', key: '0', className: '' });
+    }
+    let lineNumber = 0;
+    return codeNodes.map((node, index) => {
+      let className = node.className;
+      if (index === 0 || codeNodes[index - 1].text === '\n') {
+        lineNumber++;
+        className = `v-code-line-number ${node.className}`;
+      }
+      return {
+        text: node.text,
+        key: `${index}`,
+        className,
+        mark: `${lineNumber}`,
+      };
+    });
+  }
+  /**
+   * Check the text has special character.
+   *
+   * @param {string} text - The test text.
+   * @returns {boolean} - Return true is the text has <, > , /.
+   */
+  hasSpecialCharacter(text) {
+    return /[<|>|\\/]/.test(text);
+  }
+}
+__decorate([
+  MapToComponentField()
+], CodeHighlightParser.prototype, "value", void 0);

package/dist/collection/components/vega-code-block/slimmers/controllers/default-code-highlight-parse-controller.js

@@ -0,0 +1,34 @@
+import { CodeHighlightParser } from './code-highlight-parser.abstract';
+/**
+ * Plain text parse logic.
+ */
+export class DefaultCodeHighlightParseController extends CodeHighlightParser {
+  /**
+   * Default parser will handle if others not catch.
+   *
+   * @returns {boolean} True value.
+   */
+  canParse() {
+    const { code, language } = this.value || { code: '' };
+    return !code || !language || language === 'plainText' || !this.isHighlightLanguage(language);
+  }
+  /**
+   * The default parse will split the html tag and create the line number.
+   *
+   * @returns {CodeNodeType[]} - The code node array.
+   */
+  parse() {
+    var _a, _b;
+    const code = (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : '';
+    const nodes = code.split(/(\n)/);
+    let result = [];
+    nodes.forEach((item) => {
+      if (item) {
+        const textArray = this.splitTag(item);
+        result.push(...textArray.map((text) => ({ text, key: '', className: '' })));
+      }
+    });
+    result = this.markLineNumberNodes(result);
+    return result;
+  }
+}

package/dist/collection/components/vega-code-block/slimmers/controllers/insert-composition-text-controller.js

@@ -0,0 +1,100 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+/**
+ * The class used to control the code block insert composition text action.
+ */
+export class InsertCompositionTextController extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.insertCompositionTextEndFlag = true;
+    /**
+     * An event handler function that is triggered when the composition of text input starts. In this case,
+     *  it sets the `insertCompositionTextEndFlag` property of the `UserInputController` class to `false`.
+     *
+     * @param {CompositionEvent} e The composition event instance
+     */
+    this.handleCompositionStart = (e) => {
+      this.insertCompositionTextEndFlag = false;
+      this.stopEventPropagation(e);
+    };
+    /**
+     * An event handler function that is triggered when the composition of text input ends. In this case,
+     *  it sets the `insertCompositionTextEndFlag` property of the `UserInputController` class to `true`.
+     *
+     * @param {CompositionEvent} e The composition event instance
+     */
+    this.handleCompositionEnd = (e) => {
+      var _a;
+      this.insertCompositionTextEndFlag = true;
+      this.stopEventPropagation(e);
+      const range = this.selectionController.getCurrentRange();
+      if (range) {
+        this.selectionController.setNextCodeBlockRange(range.contentOffset + e.data.length);
+      }
+      const newContent = this.contentRenderer.getCodeContentContainerRef().innerText;
+      this.valueController.updateValue(newContent, (_a = this.value) === null || _a === void 0 ? void 0 : _a.language);
+    };
+  }
+  /**
+   * The method is to get the composition text insert end or not.
+   *
+   * @returns {boolean} The false is mean that insert composition text process is end.
+   */
+  isComposing() {
+    return !this.insertCompositionTextEndFlag;
+  }
+  /**
+   * Stop `beforeinput` and `input` event bubbles to parent element.
+   */
+  registerInputEvent() {
+    const codeContentContainerRef = this.contentRenderer.getCodeContentContainerRef();
+    if (codeContentContainerRef) {
+      codeContentContainerRef.addEventListener('compositionstart', this.handleCompositionStart);
+      codeContentContainerRef.addEventListener('compositionend', this.handleCompositionEnd);
+    }
+  }
+  /**
+   * Remove the event listener.
+   */
+  unregisterEventListener() {
+    const codeContentContainerRef = this.contentRenderer.getCodeContentContainerRef();
+    if (codeContentContainerRef) {
+      codeContentContainerRef.removeEventListener('compositionstart', this.handleCompositionStart);
+      codeContentContainerRef.removeEventListener('compositionend', this.handleCompositionEnd);
+    }
+  }
+  /**
+   * Stop the event bubbles.
+   *
+   * @param {Event} e - The event object.
+   */
+  stopEventPropagation(e) {
+    e.stopPropagation();
+  }
+}
+__decorate([
+  MapToComponentField()
+], InsertCompositionTextController.prototype, "selectionController", void 0);
+__decorate([
+  MapToComponentField()
+], InsertCompositionTextController.prototype, "contentRenderer", void 0);
+__decorate([
+  MapToComponentField()
+], InsertCompositionTextController.prototype, "valueController", void 0);
+__decorate([
+  MapToComponentField()
+], InsertCompositionTextController.prototype, "contentParseController", void 0);
+__decorate([
+  MapToComponentField()
+], InsertCompositionTextController.prototype, "value", void 0);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], InsertCompositionTextController.prototype, "registerInputEvent", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], InsertCompositionTextController.prototype, "unregisterEventListener", null);

package/dist/collection/components/vega-code-block/slimmers/controllers/prism-code-highlight-parse-controller.js

@@ -0,0 +1,86 @@
+import Prism from 'prismjs';
+// The language plugins.
+import 'prismjs/components/prism-clike';
+import 'prismjs/components/prism-javascript';
+import 'prismjs/components/prism-markup';
+import 'prismjs/components/prism-c';
+import 'prismjs/components/prism-css';
+import 'prismjs/components/prism-typescript';
+import 'prismjs/components/prism-jsx';
+import 'prismjs/components/prism-tsx';
+import { CodeHighlightParser } from './code-highlight-parser.abstract';
+/**
+ * Use the plugin Prism to highlight the code content.
+ */
+export class PrismCodeHighlightParseController extends CodeHighlightParser {
+  /**
+   * Return true when the content and language are defined.
+   *
+   * @returns {boolean} - Boolean value.
+   */
+  canParse() {
+    const { code, language } = this.value || { code: '' };
+    return code && language && this.isHighlightLanguage(language);
+  }
+  /**
+   * Use plugin to parse the string code into an array of nodes with different keywords.
+   *
+   * @returns {CodeNodeType[]} - The object contains content and highlight type.
+   */
+  parse() {
+    const { code, language } = this.value;
+    let result = [];
+    const parseLanguage = Prism.languages[language];
+    const tokens = Prism.tokenize(code, parseLanguage);
+    result = this.getHighlightNodes(tokens);
+    return this.markLineNumberNodes(result);
+  }
+  /**
+   * Parse the plugin parse result to a usable array.
+   *
+   * @param {(string | CodeHighlightToken)[]} tokens - The plugin parse result.
+   * @param {string} [type] - The keywords. Such as variable, function-name, attr-name...
+   * @returns {CodeNodeType[]} - The code node array.
+   */
+  getHighlightNodes(tokens, type) {
+    const nodes = [];
+    for (const token of tokens) {
+      if (typeof token === 'string') {
+        const partials = token.split(/(\n|\t)/);
+        const partialsLength = partials.length;
+        for (let i = 0; i < partialsLength; i++) {
+          const part = partials[i];
+          if (part) {
+            const textArray = this.splitTag(part);
+            nodes.push(...textArray.map((text) => this.createCodeNode(text, type)));
+          }
+        }
+      }
+      else {
+        const { content } = token;
+        if (typeof content === 'string') {
+          nodes.push(...this.getHighlightNodes([content], token.type));
+        }
+        else if (Array.isArray(content)) {
+          nodes.push(...this.getHighlightNodes(content, token.type));
+        }
+      }
+    }
+    return nodes;
+  }
+  /**
+   * Create a CodeNodeType type object by the code content and highlight type.
+   *
+   * @param {string} text - The code content.
+   * @param {string} highlightType - The highlight type.
+   * @returns {CodeNodeType} - The code node object.
+   */
+  createCodeNode(text, highlightType) {
+    return {
+      text,
+      key: '',
+      className: `token ${highlightType || ''}`,
+      mark: '',
+    };
+  }
+}

package/dist/collection/components/vega-code-block/slimmers/controllers/vega-code-block-content-parse-controller.js

@@ -0,0 +1,50 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
+/**
+ * Parse the code content to different tokens.
+ */
+export class CodeContentParseController extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.codeNodes = [];
+  }
+  /**
+   * Get the current rendering code node array.
+   *
+   * @returns {CodeNodeType[]} - The code node array.
+   */
+  getCurrentCodeNodes() {
+    return this.codeNodes;
+  }
+  /**
+   * Split the code content to code node array. The default parse used if the language is not defined.
+   *
+   * @returns {CodeNodeType[]} - The code node array.
+   */
+  parseCode() {
+    const parsers = [
+      this.prismCodeHighlightParser,
+      this.defaultCodeHighlightParser,
+    ];
+    let result = [];
+    for (const parser of parsers) {
+      if (parser.canParse()) {
+        result = parser.parse();
+        break;
+      }
+    }
+    this.codeNodes = result;
+    return result;
+  }
+}
+__decorate([
+  MapToComponentField()
+], CodeContentParseController.prototype, "prismCodeHighlightParser", void 0);
+__decorate([
+  MapToComponentField()
+], CodeContentParseController.prototype, "defaultCodeHighlightParser", void 0);

package/dist/collection/components/vega-code-block/slimmers/controllers/vega-code-block-focus-controller.js

@@ -0,0 +1,57 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+/**
+ * Control the component focus state.
+ */
+export class VegaCodeBlockFocusController extends VegaSlimmer {
+  /**
+   * Focus the code block and update the selection range offset to end.
+   */
+  focusAndUpdateSelection() {
+    if (!this.disabled && !this.readOnly) {
+      const codeContentContainerRef = this.contentRenderer.getCodeContentContainerRef();
+      if (codeContentContainerRef) {
+        codeContentContainerRef.focus();
+        const offset = this.value && this.value.code && this.value.code !== ' ' ? this.value.code.length : 0;
+        this.selectionController.setNextCodeBlockRange(offset, true);
+      }
+    }
+  }
+  /**
+   * Remove the focus class when component disabled or readonly.
+   */
+  removeFocusAfterDisabled() {
+    if (this.disabled || this.readOnly) {
+      this.host.classList.remove('focus');
+    }
+  }
+}
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "value", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "readOnly", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "disabled", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "contentRenderer", void 0);
+__decorate([
+  MapToComponentField()
+], VegaCodeBlockFocusController.prototype, "selectionController", void 0);
+__decorate([
+  MapToComponentMethod('doFocus')
+], VegaCodeBlockFocusController.prototype, "focusAndUpdateSelection", null);
+__decorate([
+  MapToComponentMethod('watchEditableChange')
+], VegaCodeBlockFocusController.prototype, "removeFocusAfterDisabled", null);