@easyv/biz-components 0.0.52-beta.0 → 0.0.52-beta.1

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/rename/browser/renameWidget.es.js

@@ -0,0 +1,756 @@
+import { getClientArea, getDomNodePagePosition, getTotalHeight, getTotalWidth, addDisposableListener, EventType, clearNode } from "../../../../base/browser/dom.es.js";
+import { StandardKeyboardEvent } from "../../../../base/browser/keyboardEvent.es.js";
+import { status } from "../../../../base/browser/ui/aria/aria.es.js";
+import { getBaseLayerHoverDelegate } from "../../../../base/browser/ui/hover/hoverDelegate2.es.js";
+import { getDefaultHoverDelegate } from "../../../../base/browser/ui/hover/hoverDelegateFactory.es.js";
+import { renderIcon } from "../../../../base/browser/ui/iconLabel/iconLabels.es.js";
+import { List } from "../../../../base/browser/ui/list/listWidget.es.js";
+import { distinct } from "../../../../base/common/arrays.es.js";
+import { DeferredPromise, raceCancellation } from "../../../../base/common/async.es.js";
+import { CancellationTokenSource } from "../../../../base/common/cancellation.es.js";
+import { Codicon } from "../../../../base/common/codicons.es.js";
+import { Emitter } from "../../../../base/common/event.es.js";
+import { DisposableStore, toDisposable } from "../../../../base/common/lifecycle.es.js";
+import { StopWatch } from "../../../../base/common/stopwatch.es.js";
+import { assertType, isDefined } from "../../../../base/common/types.es.js";
+/* empty css                    */
+import { applyFontInfo } from "../../../browser/config/domFontInfo.es.js";
+import { Position } from "../../../common/core/position.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { NewSymbolNameTriggerKind, NewSymbolNameTag } from "../../../common/languages.es.js";
+import { localize } from "../../../../nls.es.js";
+import { RawContextKey, IContextKeyService } from "../../../../platform/contextkey/common/contextkey.es.js";
+import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.es.js";
+import { ILogService } from "../../../../platform/log/common/log.es.js";
+import { getListStyles } from "../../../../platform/theme/browser/defaultStyles.es.js";
+import "../../../../platform/theme/common/colorUtils.es.js";
+import "../../../../platform/theme/common/colors/baseColors.es.js";
+import "../../../../platform/theme/common/colors/chartsColors.es.js";
+import { widgetShadow, widgetBorder, editorWidgetBackground } from "../../../../platform/theme/common/colors/editorColors.es.js";
+import { inputForeground, inputBorder, inputBackground } from "../../../../platform/theme/common/colors/inputColors.es.js";
+import "../../../../platform/theme/common/colors/listColors.es.js";
+import "../../../../platform/theme/common/colors/menuColors.es.js";
+import "../../../../platform/theme/common/colors/minimapColors.es.js";
+import "../../../../platform/theme/common/colors/miscColors.es.js";
+import { quickInputListFocusBackground, quickInputListFocusForeground } from "../../../../platform/theme/common/colors/quickpickColors.es.js";
+import "../../../../platform/theme/common/colors/searchColors.es.js";
+import { IThemeService } from "../../../../platform/theme/common/themeService.es.js";
+var __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;
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+const CONTEXT_RENAME_INPUT_VISIBLE = new RawContextKey("renameInputVisible", false, localize("renameInputVisible", "Whether the rename input widget is visible"));
+new RawContextKey("renameInputFocused", false, localize("renameInputFocused", "Whether the rename input widget is focused"));
+let RenameWidget = class RenameWidget2 {
+  constructor(_editor, _acceptKeybindings, _themeService, _keybindingService, contextKeyService, _logService) {
+    this._editor = _editor;
+    this._acceptKeybindings = _acceptKeybindings;
+    this._themeService = _themeService;
+    this._keybindingService = _keybindingService;
+    this._logService = _logService;
+    this.allowEditorOverflow = true;
+    this._disposables = new DisposableStore();
+    this._visibleContextKey = CONTEXT_RENAME_INPUT_VISIBLE.bindTo(contextKeyService);
+    this._isEditingRenameCandidate = false;
+    this._nRenameSuggestionsInvocations = 0;
+    this._hadAutomaticRenameSuggestionsInvocation = false;
+    this._candidates = /* @__PURE__ */ new Set();
+    this._beforeFirstInputFieldEditSW = new StopWatch();
+    this._inputWithButton = new InputWithButton();
+    this._disposables.add(this._inputWithButton);
+    this._editor.addContentWidget(this);
+    this._disposables.add(this._editor.onDidChangeConfiguration((e) => {
+      if (e.hasChanged(
+        50
+        /* EditorOption.fontInfo */
+      )) {
+        this._updateFont();
+      }
+    }));
+    this._disposables.add(_themeService.onDidColorThemeChange(this._updateStyles, this));
+  }
+  dispose() {
+    this._disposables.dispose();
+    this._editor.removeContentWidget(this);
+  }
+  getId() {
+    return "__renameInputWidget";
+  }
+  getDomNode() {
+    if (!this._domNode) {
+      this._domNode = document.createElement("div");
+      this._domNode.className = "monaco-editor rename-box";
+      this._domNode.appendChild(this._inputWithButton.domNode);
+      this._renameCandidateListView = this._disposables.add(new RenameCandidateListView(this._domNode, {
+        fontInfo: this._editor.getOption(
+          50
+          /* EditorOption.fontInfo */
+        ),
+        onFocusChange: (newSymbolName) => {
+          this._inputWithButton.input.value = newSymbolName;
+          this._isEditingRenameCandidate = false;
+        },
+        onSelectionChange: () => {
+          this._isEditingRenameCandidate = false;
+          this.acceptInput(false);
+        }
+      }));
+      this._disposables.add(this._inputWithButton.onDidInputChange(() => {
+        var _a, _b, _c;
+        if (((_a = this._renameCandidateListView) == null ? void 0 : _a.focusedCandidate) !== void 0) {
+          this._isEditingRenameCandidate = true;
+        }
+        this._timeBeforeFirstInputFieldEdit ?? (this._timeBeforeFirstInputFieldEdit = this._beforeFirstInputFieldEditSW.elapsed());
+        if (((_b = this._renameCandidateProvidersCts) == null ? void 0 : _b.token.isCancellationRequested) === false) {
+          this._renameCandidateProvidersCts.cancel();
+        }
+        (_c = this._renameCandidateListView) == null ? void 0 : _c.clearFocus();
+      }));
+      this._label = document.createElement("div");
+      this._label.className = "rename-label";
+      this._domNode.appendChild(this._label);
+      this._updateFont();
+      this._updateStyles(this._themeService.getColorTheme());
+    }
+    return this._domNode;
+  }
+  _updateStyles(theme) {
+    if (!this._domNode) {
+      return;
+    }
+    const widgetShadowColor = theme.getColor(widgetShadow);
+    const widgetBorderColor = theme.getColor(widgetBorder);
+    this._domNode.style.backgroundColor = String(theme.getColor(editorWidgetBackground) ?? "");
+    this._domNode.style.boxShadow = widgetShadowColor ? ` 0 0 8px 2px ${widgetShadowColor}` : "";
+    this._domNode.style.border = widgetBorderColor ? `1px solid ${widgetBorderColor}` : "";
+    this._domNode.style.color = String(theme.getColor(inputForeground) ?? "");
+    const border = theme.getColor(inputBorder);
+    this._inputWithButton.domNode.style.backgroundColor = String(theme.getColor(inputBackground) ?? "");
+    this._inputWithButton.input.style.backgroundColor = String(theme.getColor(inputBackground) ?? "");
+    this._inputWithButton.domNode.style.borderWidth = border ? "1px" : "0px";
+    this._inputWithButton.domNode.style.borderStyle = border ? "solid" : "none";
+    this._inputWithButton.domNode.style.borderColor = (border == null ? void 0 : border.toString()) ?? "none";
+  }
+  _updateFont() {
+    if (this._domNode === void 0) {
+      return;
+    }
+    assertType(this._label !== void 0, "RenameWidget#_updateFont: _label must not be undefined given _domNode is defined");
+    this._editor.applyFontInfo(this._inputWithButton.input);
+    const fontInfo = this._editor.getOption(
+      50
+      /* EditorOption.fontInfo */
+    );
+    this._label.style.fontSize = `${this._computeLabelFontSize(fontInfo.fontSize)}px`;
+  }
+  _computeLabelFontSize(editorFontSize) {
+    return editorFontSize * 0.8;
+  }
+  getPosition() {
+    if (!this._visible) {
+      return null;
+    }
+    if (!this._editor.hasModel() || // @ulugbekna: shouldn't happen
+    !this._editor.getDomNode()) {
+      return null;
+    }
+    const bodyBox = getClientArea(this.getDomNode().ownerDocument.body);
+    const editorBox = getDomNodePagePosition(this._editor.getDomNode());
+    const cursorBoxTop = this._getTopForPosition();
+    this._nPxAvailableAbove = cursorBoxTop + editorBox.top;
+    this._nPxAvailableBelow = bodyBox.height - this._nPxAvailableAbove;
+    const lineHeight = this._editor.getOption(
+      67
+      /* EditorOption.lineHeight */
+    );
+    const { totalHeight: candidateViewHeight } = RenameCandidateView.getLayoutInfo({ lineHeight });
+    const positionPreference = this._nPxAvailableBelow > candidateViewHeight * 6 ? [
+      2,
+      1
+      /* ContentWidgetPositionPreference.ABOVE */
+    ] : [
+      1,
+      2
+      /* ContentWidgetPositionPreference.BELOW */
+    ];
+    return {
+      position: this._position,
+      preference: positionPreference
+    };
+  }
+  beforeRender() {
+    var _a, _b;
+    const [accept, preview] = this._acceptKeybindings;
+    this._label.innerText = localize({ key: "label", comment: ['placeholders are keybindings, e.g "F2 to Rename, Shift+F2 to Preview"'] }, "{0} to Rename, {1} to Preview", (_a = this._keybindingService.lookupKeybinding(accept)) == null ? void 0 : _a.getLabel(), (_b = this._keybindingService.lookupKeybinding(preview)) == null ? void 0 : _b.getLabel());
+    this._domNode.style.minWidth = `200px`;
+    return null;
+  }
+  afterRender(position) {
+    if (position === null) {
+      this.cancelInput(true, "afterRender (because position is null)");
+      return;
+    }
+    if (!this._editor.hasModel() || // shouldn't happen
+    !this._editor.getDomNode()) {
+      return;
+    }
+    assertType(this._renameCandidateListView);
+    assertType(this._nPxAvailableAbove !== void 0);
+    assertType(this._nPxAvailableBelow !== void 0);
+    const inputBoxHeight = getTotalHeight(this._inputWithButton.domNode);
+    const labelHeight = getTotalHeight(this._label);
+    let totalHeightAvailable;
+    if (position === 2) {
+      totalHeightAvailable = this._nPxAvailableBelow;
+    } else {
+      totalHeightAvailable = this._nPxAvailableAbove;
+    }
+    this._renameCandidateListView.layout({
+      height: totalHeightAvailable - labelHeight - inputBoxHeight,
+      width: getTotalWidth(this._inputWithButton.domNode)
+    });
+  }
+  acceptInput(wantsPreview) {
+    var _a;
+    this._trace(`invoking acceptInput`);
+    (_a = this._currentAcceptInput) == null ? void 0 : _a.call(this, wantsPreview);
+  }
+  cancelInput(focusEditor, caller) {
+    var _a;
+    (_a = this._currentCancelInput) == null ? void 0 : _a.call(this, focusEditor);
+  }
+  focusNextRenameSuggestion() {
+    var _a;
+    if (!((_a = this._renameCandidateListView) == null ? void 0 : _a.focusNext())) {
+      this._inputWithButton.input.value = this._currentName;
+    }
+  }
+  focusPreviousRenameSuggestion() {
+    var _a;
+    if (!((_a = this._renameCandidateListView) == null ? void 0 : _a.focusPrevious())) {
+      this._inputWithButton.input.value = this._currentName;
+    }
+  }
+  /**
+   * @param requestRenameCandidates is `undefined` when there are no rename suggestion providers
+   */
+  getInput(where, currentName, supportPreview, requestRenameCandidates, cts) {
+    const { start: selectionStart, end: selectionEnd } = this._getSelection(where, currentName);
+    this._renameCts = cts;
+    const disposeOnDone = new DisposableStore();
+    this._nRenameSuggestionsInvocations = 0;
+    this._hadAutomaticRenameSuggestionsInvocation = false;
+    if (requestRenameCandidates === void 0) {
+      this._inputWithButton.button.style.display = "none";
+    } else {
+      this._inputWithButton.button.style.display = "flex";
+      this._requestRenameCandidatesOnce = requestRenameCandidates;
+      this._requestRenameCandidates(currentName, false);
+      disposeOnDone.add(addDisposableListener(this._inputWithButton.button, "click", () => this._requestRenameCandidates(currentName, true)));
+      disposeOnDone.add(addDisposableListener(this._inputWithButton.button, EventType.KEY_DOWN, (e) => {
+        const keyEvent = new StandardKeyboardEvent(e);
+        if (keyEvent.equals(
+          3
+          /* KeyCode.Enter */
+        ) || keyEvent.equals(
+          10
+          /* KeyCode.Space */
+        )) {
+          keyEvent.stopPropagation();
+          keyEvent.preventDefault();
+          this._requestRenameCandidates(currentName, true);
+        }
+      }));
+    }
+    this._isEditingRenameCandidate = false;
+    this._domNode.classList.toggle("preview", supportPreview);
+    this._position = new Position(where.startLineNumber, where.startColumn);
+    this._currentName = currentName;
+    this._inputWithButton.input.value = currentName;
+    this._inputWithButton.input.setAttribute("selectionStart", selectionStart.toString());
+    this._inputWithButton.input.setAttribute("selectionEnd", selectionEnd.toString());
+    this._inputWithButton.input.size = Math.max((where.endColumn - where.startColumn) * 1.1, 20);
+    this._beforeFirstInputFieldEditSW.reset();
+    disposeOnDone.add(toDisposable(() => {
+      this._renameCts = void 0;
+      cts.dispose(true);
+    }));
+    disposeOnDone.add(toDisposable(() => {
+      if (this._renameCandidateProvidersCts !== void 0) {
+        this._renameCandidateProvidersCts.dispose(true);
+        this._renameCandidateProvidersCts = void 0;
+      }
+    }));
+    disposeOnDone.add(toDisposable(() => this._candidates.clear()));
+    const inputResult = new DeferredPromise();
+    inputResult.p.finally(() => {
+      disposeOnDone.dispose();
+      this._hide();
+    });
+    this._currentCancelInput = (focusEditor) => {
+      var _a;
+      this._trace("invoking _currentCancelInput");
+      this._currentAcceptInput = void 0;
+      this._currentCancelInput = void 0;
+      (_a = this._renameCandidateListView) == null ? void 0 : _a.clearCandidates();
+      inputResult.complete(focusEditor);
+      return true;
+    };
+    this._currentAcceptInput = (wantsPreview) => {
+      this._trace("invoking _currentAcceptInput");
+      assertType(this._renameCandidateListView !== void 0);
+      const nRenameSuggestions = this._renameCandidateListView.nCandidates;
+      let newName;
+      let source;
+      const focusedCandidate = this._renameCandidateListView.focusedCandidate;
+      if (focusedCandidate !== void 0) {
+        this._trace("using new name from renameSuggestion");
+        newName = focusedCandidate;
+        source = { k: "renameSuggestion" };
+      } else {
+        this._trace("using new name from inputField");
+        newName = this._inputWithButton.input.value;
+        source = this._isEditingRenameCandidate ? { k: "userEditedRenameSuggestion" } : { k: "inputField" };
+      }
+      if (newName === currentName || newName.trim().length === 0) {
+        this.cancelInput(true, "_currentAcceptInput (because newName === value || newName.trim().length === 0)");
+        return;
+      }
+      this._currentAcceptInput = void 0;
+      this._currentCancelInput = void 0;
+      this._renameCandidateListView.clearCandidates();
+      inputResult.complete({
+        newName,
+        wantsPreview: supportPreview && wantsPreview,
+        stats: {
+          source,
+          nRenameSuggestions,
+          timeBeforeFirstInputFieldEdit: this._timeBeforeFirstInputFieldEdit,
+          nRenameSuggestionsInvocations: this._nRenameSuggestionsInvocations,
+          hadAutomaticRenameSuggestionsInvocation: this._hadAutomaticRenameSuggestionsInvocation
+        }
+      });
+    };
+    disposeOnDone.add(cts.token.onCancellationRequested(() => this.cancelInput(true, "cts.token.onCancellationRequested")));
+    {
+      disposeOnDone.add(this._editor.onDidBlurEditorWidget(() => {
+        var _a;
+        return this.cancelInput(!((_a = this._domNode) == null ? void 0 : _a.ownerDocument.hasFocus()), "editor.onDidBlurEditorWidget");
+      }));
+    }
+    this._show();
+    return inputResult.p;
+  }
+  _requestRenameCandidates(currentName, isManuallyTriggered) {
+    if (this._requestRenameCandidatesOnce === void 0) {
+      return;
+    }
+    if (this._renameCandidateProvidersCts !== void 0) {
+      this._renameCandidateProvidersCts.dispose(true);
+    }
+    assertType(this._renameCts);
+    if (this._inputWithButton.buttonState !== "stop") {
+      this._renameCandidateProvidersCts = new CancellationTokenSource();
+      const triggerKind = isManuallyTriggered ? NewSymbolNameTriggerKind.Invoke : NewSymbolNameTriggerKind.Automatic;
+      const candidates = this._requestRenameCandidatesOnce(triggerKind, this._renameCandidateProvidersCts.token);
+      if (candidates.length === 0) {
+        this._inputWithButton.setSparkleButton();
+        return;
+      }
+      if (!isManuallyTriggered) {
+        this._hadAutomaticRenameSuggestionsInvocation = true;
+      }
+      this._nRenameSuggestionsInvocations += 1;
+      this._inputWithButton.setStopButton();
+      this._updateRenameCandidates(candidates, currentName, this._renameCts.token);
+    }
+  }
+  /**
+   * This allows selecting only part of the symbol name in the input field based on the selection in the editor
+   */
+  _getSelection(where, currentName) {
+    assertType(this._editor.hasModel());
+    const selection = this._editor.getSelection();
+    let start = 0;
+    let end = currentName.length;
+    if (!Range.isEmpty(selection) && !Range.spansMultipleLines(selection) && Range.containsRange(where, selection)) {
+      start = Math.max(0, selection.startColumn - where.startColumn);
+      end = Math.min(where.endColumn, selection.endColumn) - where.startColumn;
+    }
+    return { start, end };
+  }
+  _show() {
+    this._trace("invoking _show");
+    this._editor.revealLineInCenterIfOutsideViewport(
+      this._position.lineNumber,
+      0
+      /* ScrollType.Smooth */
+    );
+    this._visible = true;
+    this._visibleContextKey.set(true);
+    this._editor.layoutContentWidget(this);
+    setTimeout(() => {
+      this._inputWithButton.input.focus();
+      this._inputWithButton.input.setSelectionRange(parseInt(this._inputWithButton.input.getAttribute("selectionStart")), parseInt(this._inputWithButton.input.getAttribute("selectionEnd")));
+    }, 100);
+  }
+  async _updateRenameCandidates(candidates, currentName, token) {
+    const trace = (...args) => this._trace("_updateRenameCandidates", ...args);
+    trace("start");
+    const namesListResults = await raceCancellation(Promise.allSettled(candidates), token);
+    this._inputWithButton.setSparkleButton();
+    if (namesListResults === void 0) {
+      trace("returning early - received updateRenameCandidates results - undefined");
+      return;
+    }
+    const newNames = namesListResults.flatMap((namesListResult) => namesListResult.status === "fulfilled" && isDefined(namesListResult.value) ? namesListResult.value : []);
+    trace(`received updateRenameCandidates results - total (unfiltered) ${newNames.length} candidates.`);
+    const distinctNames = distinct(newNames, (v) => v.newSymbolName);
+    trace(`distinct candidates - ${distinctNames.length} candidates.`);
+    const validDistinctNames = distinctNames.filter(({ newSymbolName }) => newSymbolName.trim().length > 0 && newSymbolName !== this._inputWithButton.input.value && newSymbolName !== currentName && !this._candidates.has(newSymbolName));
+    trace(`valid distinct candidates - ${newNames.length} candidates.`);
+    validDistinctNames.forEach((n) => this._candidates.add(n.newSymbolName));
+    if (validDistinctNames.length < 1) {
+      trace("returning early - no valid distinct candidates");
+      return;
+    }
+    trace("setting candidates");
+    this._renameCandidateListView.setCandidates(validDistinctNames);
+    trace("asking editor to re-layout");
+    this._editor.layoutContentWidget(this);
+  }
+  _hide() {
+    this._trace("invoked _hide");
+    this._visible = false;
+    this._visibleContextKey.reset();
+    this._editor.layoutContentWidget(this);
+  }
+  _getTopForPosition() {
+    const visibleRanges = this._editor.getVisibleRanges();
+    let firstLineInViewport;
+    if (visibleRanges.length > 0) {
+      firstLineInViewport = visibleRanges[0].startLineNumber;
+    } else {
+      this._logService.warn("RenameWidget#_getTopForPosition: this should not happen - visibleRanges is empty");
+      firstLineInViewport = Math.max(1, this._position.lineNumber - 5);
+    }
+    return this._editor.getTopForLineNumber(this._position.lineNumber) - this._editor.getTopForLineNumber(firstLineInViewport);
+  }
+  _trace(...args) {
+    this._logService.trace("RenameWidget", ...args);
+  }
+};
+RenameWidget = __decorate([
+  __param(2, IThemeService),
+  __param(3, IKeybindingService),
+  __param(4, IContextKeyService),
+  __param(5, ILogService)
+], RenameWidget);
+class RenameCandidateListView {
+  // FIXME@ulugbekna: rewrite using event emitters
+  constructor(parent, opts) {
+    this._disposables = new DisposableStore();
+    this._availableHeight = 0;
+    this._minimumWidth = 0;
+    this._lineHeight = opts.fontInfo.lineHeight;
+    this._typicalHalfwidthCharacterWidth = opts.fontInfo.typicalHalfwidthCharacterWidth;
+    this._listContainer = document.createElement("div");
+    this._listContainer.className = "rename-box rename-candidate-list-container";
+    parent.appendChild(this._listContainer);
+    this._listWidget = RenameCandidateListView._createListWidget(this._listContainer, this._candidateViewHeight, opts.fontInfo);
+    this._listWidget.onDidChangeFocus((e) => {
+      if (e.elements.length === 1) {
+        opts.onFocusChange(e.elements[0].newSymbolName);
+      }
+    }, this._disposables);
+    this._listWidget.onDidChangeSelection((e) => {
+      if (e.elements.length === 1) {
+        opts.onSelectionChange();
+      }
+    }, this._disposables);
+    this._disposables.add(this._listWidget.onDidBlur((e) => {
+      this._listWidget.setFocus([]);
+    }));
+    this._listWidget.style(getListStyles({
+      listInactiveFocusForeground: quickInputListFocusForeground,
+      listInactiveFocusBackground: quickInputListFocusBackground
+    }));
+  }
+  dispose() {
+    this._listWidget.dispose();
+    this._disposables.dispose();
+  }
+  // height - max height allowed by parent element
+  layout({ height, width }) {
+    this._availableHeight = height;
+    this._minimumWidth = width;
+  }
+  setCandidates(candidates) {
+    this._listWidget.splice(0, 0, candidates);
+    const height = this._pickListHeight(this._listWidget.length);
+    const width = this._pickListWidth(candidates);
+    this._listWidget.layout(height, width);
+    this._listContainer.style.height = `${height}px`;
+    this._listContainer.style.width = `${width}px`;
+    status(localize("renameSuggestionsReceivedAria", "Received {0} rename suggestions", candidates.length));
+  }
+  clearCandidates() {
+    this._listContainer.style.height = "0px";
+    this._listContainer.style.width = "0px";
+    this._listWidget.splice(0, this._listWidget.length, []);
+  }
+  get nCandidates() {
+    return this._listWidget.length;
+  }
+  get focusedCandidate() {
+    if (this._listWidget.length === 0) {
+      return;
+    }
+    const selectedElement = this._listWidget.getSelectedElements()[0];
+    if (selectedElement !== void 0) {
+      return selectedElement.newSymbolName;
+    }
+    const focusedElement = this._listWidget.getFocusedElements()[0];
+    if (focusedElement !== void 0) {
+      return focusedElement.newSymbolName;
+    }
+    return;
+  }
+  focusNext() {
+    if (this._listWidget.length === 0) {
+      return false;
+    }
+    const focusedIxs = this._listWidget.getFocus();
+    if (focusedIxs.length === 0) {
+      this._listWidget.focusFirst();
+      this._listWidget.reveal(0);
+      return true;
+    } else {
+      if (focusedIxs[0] === this._listWidget.length - 1) {
+        this._listWidget.setFocus([]);
+        this._listWidget.reveal(0);
+        return false;
+      } else {
+        this._listWidget.focusNext();
+        const focused = this._listWidget.getFocus()[0];
+        this._listWidget.reveal(focused);
+        return true;
+      }
+    }
+  }
+  /**
+   * @returns true if focus is moved to previous element
+   */
+  focusPrevious() {
+    if (this._listWidget.length === 0) {
+      return false;
+    }
+    const focusedIxs = this._listWidget.getFocus();
+    if (focusedIxs.length === 0) {
+      this._listWidget.focusLast();
+      const focused = this._listWidget.getFocus()[0];
+      this._listWidget.reveal(focused);
+      return true;
+    } else {
+      if (focusedIxs[0] === 0) {
+        this._listWidget.setFocus([]);
+        return false;
+      } else {
+        this._listWidget.focusPrevious();
+        const focused = this._listWidget.getFocus()[0];
+        this._listWidget.reveal(focused);
+        return true;
+      }
+    }
+  }
+  clearFocus() {
+    this._listWidget.setFocus([]);
+  }
+  get _candidateViewHeight() {
+    const { totalHeight } = RenameCandidateView.getLayoutInfo({ lineHeight: this._lineHeight });
+    return totalHeight;
+  }
+  _pickListHeight(nCandidates) {
+    const heightToFitAllCandidates = this._candidateViewHeight * nCandidates;
+    const MAX_N_CANDIDATES = 7;
+    const height = Math.min(heightToFitAllCandidates, this._availableHeight, this._candidateViewHeight * MAX_N_CANDIDATES);
+    return height;
+  }
+  _pickListWidth(candidates) {
+    const longestCandidateWidth = Math.ceil(Math.max(...candidates.map((c) => c.newSymbolName.length)) * this._typicalHalfwidthCharacterWidth);
+    const width = Math.max(
+      this._minimumWidth,
+      4 + 16 + 5 + longestCandidateWidth + 10
+      /* (possibly visible) scrollbar width */
+      // TODO@ulugbekna: approximate calc - clean this up
+    );
+    return width;
+  }
+  static _createListWidget(container, candidateViewHeight, fontInfo) {
+    const virtualDelegate = new class {
+      getTemplateId(element) {
+        return "candidate";
+      }
+      getHeight(element) {
+        return candidateViewHeight;
+      }
+    }();
+    const renderer = new class {
+      constructor() {
+        this.templateId = "candidate";
+      }
+      renderTemplate(container2) {
+        return new RenameCandidateView(container2, fontInfo);
+      }
+      renderElement(candidate, index, templateData) {
+        templateData.populate(candidate);
+      }
+      disposeTemplate(templateData) {
+        templateData.dispose();
+      }
+    }();
+    return new List("NewSymbolNameCandidates", container, virtualDelegate, [renderer], {
+      keyboardSupport: false,
+      // @ulugbekna: because we handle keyboard events through proper commands & keybinding service, see `rename.ts`
+      mouseSupport: true,
+      multipleSelectionSupport: false
+    });
+  }
+}
+class InputWithButton {
+  constructor() {
+    this._onDidInputChange = new Emitter();
+    this.onDidInputChange = this._onDidInputChange.event;
+    this._disposables = new DisposableStore();
+  }
+  get domNode() {
+    if (!this._domNode) {
+      this._domNode = document.createElement("div");
+      this._domNode.className = "rename-input-with-button";
+      this._domNode.style.display = "flex";
+      this._domNode.style.flexDirection = "row";
+      this._domNode.style.alignItems = "center";
+      this._inputNode = document.createElement("input");
+      this._inputNode.className = "rename-input";
+      this._inputNode.type = "text";
+      this._inputNode.style.border = "none";
+      this._inputNode.setAttribute("aria-label", localize("renameAriaLabel", "Rename input. Type new name and press Enter to commit."));
+      this._domNode.appendChild(this._inputNode);
+      this._buttonNode = document.createElement("div");
+      this._buttonNode.className = "rename-suggestions-button";
+      this._buttonNode.setAttribute("tabindex", "0");
+      this._buttonGenHoverText = localize("generateRenameSuggestionsButton", "Generate new name suggestions");
+      this._buttonCancelHoverText = localize("cancelRenameSuggestionsButton", "Cancel");
+      this._buttonHover = getBaseLayerHoverDelegate().setupManagedHover(getDefaultHoverDelegate("element"), this._buttonNode, this._buttonGenHoverText);
+      this._disposables.add(this._buttonHover);
+      this._domNode.appendChild(this._buttonNode);
+      this._disposables.add(addDisposableListener(this.input, EventType.INPUT, () => this._onDidInputChange.fire()));
+      this._disposables.add(addDisposableListener(this.input, EventType.KEY_DOWN, (e) => {
+        const keyEvent = new StandardKeyboardEvent(e);
+        if (keyEvent.keyCode === 15 || keyEvent.keyCode === 17) {
+          this._onDidInputChange.fire();
+        }
+      }));
+      this._disposables.add(addDisposableListener(this.input, EventType.CLICK, () => this._onDidInputChange.fire()));
+      this._disposables.add(addDisposableListener(this.input, EventType.FOCUS, () => {
+        this.domNode.style.outlineWidth = "1px";
+        this.domNode.style.outlineStyle = "solid";
+        this.domNode.style.outlineOffset = "-1px";
+        this.domNode.style.outlineColor = "var(--vscode-focusBorder)";
+      }));
+      this._disposables.add(addDisposableListener(this.input, EventType.BLUR, () => {
+        this.domNode.style.outline = "none";
+      }));
+    }
+    return this._domNode;
+  }
+  get input() {
+    assertType(this._inputNode);
+    return this._inputNode;
+  }
+  get button() {
+    assertType(this._buttonNode);
+    return this._buttonNode;
+  }
+  get buttonState() {
+    return this._buttonState;
+  }
+  setSparkleButton() {
+    var _a;
+    this._buttonState = "sparkle";
+    this._sparkleIcon ?? (this._sparkleIcon = renderIcon(Codicon.sparkle));
+    clearNode(this.button);
+    this.button.appendChild(this._sparkleIcon);
+    this.button.setAttribute("aria-label", "Generating new name suggestions");
+    (_a = this._buttonHover) == null ? void 0 : _a.update(this._buttonGenHoverText);
+    this.input.focus();
+  }
+  setStopButton() {
+    var _a;
+    this._buttonState = "stop";
+    this._stopIcon ?? (this._stopIcon = renderIcon(Codicon.primitiveSquare));
+    clearNode(this.button);
+    this.button.appendChild(this._stopIcon);
+    this.button.setAttribute("aria-label", "Cancel generating new name suggestions");
+    (_a = this._buttonHover) == null ? void 0 : _a.update(this._buttonCancelHoverText);
+    this.input.focus();
+  }
+  dispose() {
+    this._disposables.dispose();
+  }
+}
+const _RenameCandidateView = class _RenameCandidateView {
+  constructor(parent, fontInfo) {
+    this._domNode = document.createElement("div");
+    this._domNode.className = "rename-box rename-candidate";
+    this._domNode.style.display = `flex`;
+    this._domNode.style.columnGap = `5px`;
+    this._domNode.style.alignItems = `center`;
+    this._domNode.style.height = `${fontInfo.lineHeight}px`;
+    this._domNode.style.padding = `${_RenameCandidateView._PADDING}px`;
+    const iconContainer = document.createElement("div");
+    iconContainer.style.display = `flex`;
+    iconContainer.style.alignItems = `center`;
+    iconContainer.style.width = iconContainer.style.height = `${fontInfo.lineHeight * 0.8}px`;
+    this._domNode.appendChild(iconContainer);
+    this._icon = renderIcon(Codicon.sparkle);
+    this._icon.style.display = `none`;
+    iconContainer.appendChild(this._icon);
+    this._label = document.createElement("div");
+    applyFontInfo(this._label, fontInfo);
+    this._domNode.appendChild(this._label);
+    parent.appendChild(this._domNode);
+  }
+  populate(value) {
+    this._updateIcon(value);
+    this._updateLabel(value);
+  }
+  _updateIcon(value) {
+    var _a;
+    const isAIGenerated = !!((_a = value.tags) == null ? void 0 : _a.includes(NewSymbolNameTag.AIGenerated));
+    this._icon.style.display = isAIGenerated ? "inherit" : "none";
+  }
+  _updateLabel(value) {
+    this._label.innerText = value.newSymbolName;
+  }
+  static getLayoutInfo({ lineHeight }) {
+    const totalHeight = lineHeight + _RenameCandidateView._PADDING * 2;
+    return { totalHeight };
+  }
+  dispose() {
+  }
+};
+_RenameCandidateView._PADDING = 2;
+let RenameCandidateView = _RenameCandidateView;
+export {
+  CONTEXT_RENAME_INPUT_VISIBLE,
+  RenameWidget
+};
+//# sourceMappingURL=renameWidget.es.js.map