@microsoft/vscode-ui 1.0.1-alpha.0028ae747.0

package/build/ui.js

@@ -0,0 +1,938 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSCodeUI = exports.sleep = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
+const path = tslib_1.__importStar(require("path"));
+const vscode_1 = require("vscode");
+const teamsfx_api_1 = require("@microsoft/teamsfx-api");
+const progressHandler_1 = require("./progressHandler");
+const error_1 = require("./error");
+const localize_1 = require("./localize");
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+exports.sleep = sleep;
+function getOptionItem(item) {
+    return {
+        id: item.id,
+        label: item.label,
+        description: item.description,
+        detail: item.detail,
+        data: item.data,
+    };
+}
+function convertToFxQuickPickItems(options) {
+    if (options && options.length > 0 && typeof options[0] === "string") {
+        return options.map((option) => {
+            return { id: option, label: option };
+        });
+    }
+    else {
+        const result = [];
+        const candidates = [...options];
+        while (candidates.length > 0) {
+            const groupName = candidates[0].groupName;
+            const group = lodash_1.remove(candidates, (option) => option.groupName === groupName);
+            if (groupName) {
+                result.push({
+                    id: groupName,
+                    label: groupName,
+                    kind: vscode_1.QuickPickItemKind.Separator,
+                });
+            }
+            result.push(...group.map((option) => {
+                var _a;
+                return {
+                    id: option.id,
+                    label: option.label,
+                    description: option.description,
+                    detail: option.detail,
+                    data: option.data,
+                    buttons: (_a = option.buttons) === null || _a === void 0 ? void 0 : _a.map((button) => {
+                        return { iconPath: new vscode_1.ThemeIcon(button.iconPath), tooltip: button.tooltip };
+                    }),
+                };
+            }));
+        }
+        return result;
+    }
+}
+function cloneSet(set) {
+    const res = new Set();
+    for (const e of set)
+        res.add(e);
+    return res;
+}
+function isSame(set1, set2) {
+    for (const i of set1) {
+        if (!set2.has(i))
+            return false;
+    }
+    for (const i of set2) {
+        if (!set1.has(i))
+            return false;
+    }
+    return true;
+}
+/***
+ * This is the default implementation of UserInteraction in vscode.
+ */
+class VSCodeUI {
+    constructor(terminalName, assembleError, localizer) {
+        this.terminalName = terminalName;
+        this.assembleError = assembleError;
+        this.localizer = localizer || new localize_1.DefaultLocalizer();
+    }
+    async selectOption(config) {
+        if (typeof config.options === "object" && config.options.length === 0) {
+            return teamsfx_api_1.err(new error_1.EmptyOptionsError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage()));
+        }
+        const disposables = [];
+        try {
+            const quickPick = vscode_1.window.createQuickPick();
+            quickPick.title = config.title;
+            const buttons = config.buttons
+                ? config.buttons.map((button) => {
+                    return {
+                        iconPath: new vscode_1.ThemeIcon(button.icon),
+                        tooltip: button.tooltip,
+                    };
+                })
+                : [];
+            if (config.step && config.step > 1) {
+                quickPick.buttons = [vscode_1.QuickInputButtons.Back, ...buttons];
+            }
+            else {
+                quickPick.buttons = buttons;
+            }
+            quickPick.placeholder = config.placeholder;
+            quickPick.ignoreFocusOut = true;
+            quickPick.matchOnDescription = true;
+            quickPick.matchOnDetail = true;
+            quickPick.canSelectMany = false;
+            return await new Promise((resolve) => {
+                let options = [];
+                let defaultValue = undefined;
+                let isSkip = false;
+                const onDidAccept = async () => {
+                    const selectedItems = quickPick.selectedItems;
+                    if (selectedItems && selectedItems.length > 0) {
+                        const item = selectedItems[0];
+                        let result;
+                        if (typeof options[0] === "string" ||
+                            config.returnObject === undefined ||
+                            config.returnObject === false) {
+                            result = item.id;
+                            if (config.validation) {
+                                try {
+                                    const validateRes = await config.validation(result);
+                                    if (validateRes) {
+                                        return;
+                                    }
+                                }
+                                catch (e) {
+                                    resolve(teamsfx_api_1.err(this.assembleError(e)));
+                                }
+                            }
+                        }
+                        else
+                            result = getOptionItem(item);
+                        resolve(teamsfx_api_1.ok({ type: isSkip ? "skip" : "success", result: result }));
+                    }
+                };
+                const loadDynamicData = async () => {
+                    quickPick.busy = true;
+                    quickPick.placeholder = this.localizer.loadingOptionsPlaceholder();
+                    try {
+                        if (typeof config.options === "function") {
+                            options = await config.options();
+                        }
+                        else {
+                            options = config.options;
+                        }
+                        if (typeof config.default === "function") {
+                            defaultValue = await config.default();
+                        }
+                        else {
+                            defaultValue = config.default;
+                        }
+                    }
+                    catch (e) {
+                        resolve(teamsfx_api_1.err(this.assembleError(e)));
+                    }
+                };
+                const onDataLoaded = () => {
+                    quickPick.busy = false;
+                    quickPick.placeholder = config.placeholder;
+                    quickPick.items = convertToFxQuickPickItems(options);
+                    if (config.skipSingleOption && options.length === 1) {
+                        quickPick.selectedItems = [quickPick.items[0]];
+                        isSkip = true;
+                        void onDidAccept();
+                        return;
+                    }
+                    if (defaultValue) {
+                        if (options && options.length > 0 && typeof options[0] === "string") {
+                            const defaultOption = options.find((o) => o == defaultValue);
+                            if (defaultOption) {
+                                const newItems = options.filter((o) => o != defaultValue);
+                                newItems.unshift(defaultOption);
+                                quickPick.items = convertToFxQuickPickItems(newItems);
+                            }
+                        }
+                        else {
+                            const defaultOption = options.find((o) => o.id == defaultValue);
+                            if (defaultOption) {
+                                const newItems = options.filter((o) => o.id != defaultValue);
+                                newItems.unshift(defaultOption);
+                                quickPick.items = convertToFxQuickPickItems(newItems);
+                            }
+                        }
+                    }
+                };
+                disposables.push(quickPick.onDidAccept(onDidAccept), quickPick.onDidHide(() => {
+                    resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.cancelErrorMessage(), this.localizer.cancelErrorDisplayMessage())));
+                }), quickPick.onDidTriggerButton(async (button) => {
+                    var _a;
+                    if (button === vscode_1.QuickInputButtons.Back)
+                        resolve(teamsfx_api_1.ok({ type: "back" }));
+                    else if (config.buttons && buttons.indexOf(button) !== -1) {
+                        const curButton = (_a = config.buttons) === null || _a === void 0 ? void 0 : _a.find((btn) => {
+                            return (btn.icon === button.iconPath.id && btn.tooltip === button.tooltip);
+                        });
+                        if (curButton) {
+                            await vscode_1.commands.executeCommand(curButton.command);
+                        }
+                    }
+                    else {
+                        quickPick.selectedItems = quickPick.activeItems;
+                        await onDidAccept();
+                    }
+                }), quickPick.onDidTriggerItemButton(async (event) => {
+                    var _a;
+                    const itemOptions = options;
+                    if (itemOptions.length > 0 && typeof itemOptions[0] === "string") {
+                        return;
+                    }
+                    const triggerItem = itemOptions.find((singleOption) => {
+                        if (typeof singleOption !== "string") {
+                            return singleOption.id === event.item.id;
+                        }
+                    });
+                    if (triggerItem) {
+                        const triggerButton = (_a = triggerItem.buttons) === null || _a === void 0 ? void 0 : _a.find((button) => {
+                            return button.iconPath === event.button.iconPath.id;
+                        });
+                        if (triggerButton) {
+                            await vscode_1.commands.executeCommand(triggerButton.command, event.item);
+                        }
+                    }
+                }));
+                disposables.push(quickPick);
+                if (typeof config.options === "function" || typeof config.default === "function") {
+                    // try to load dynamic data in a very short time
+                    const timeoutPromise = new Promise((resolve) => {
+                        setTimeout(resolve, 500, this.localizer.loadingOptionsTimeoutMessage());
+                    });
+                    Promise.race([loadDynamicData(), timeoutPromise])
+                        .then((value) => {
+                        if (value != this.localizer.loadingOptionsTimeoutMessage()) {
+                            if (config.skipSingleOption && options.length === 1) {
+                                quickPick.items = convertToFxQuickPickItems(options);
+                                quickPick.selectedItems = [quickPick.items[0]];
+                                isSkip = true;
+                                void onDidAccept();
+                                return;
+                            }
+                            else {
+                                onDataLoaded();
+                                quickPick.show();
+                            }
+                        }
+                        else {
+                            quickPick.show();
+                            loadDynamicData()
+                                .then(onDataLoaded)
+                                .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                        }
+                    })
+                        .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                }
+                else {
+                    options = config.options;
+                    defaultValue = config.default;
+                    onDataLoaded();
+                    quickPick.show();
+                }
+            });
+        }
+        finally {
+            disposables.forEach((d) => {
+                d.dispose();
+            });
+        }
+    }
+    async selectOptions(config) {
+        if (typeof config.options === "object" && config.options.length === 0) {
+            return teamsfx_api_1.err(new error_1.EmptyOptionsError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage()));
+        }
+        const disposables = [];
+        try {
+            const quickPick = vscode_1.window.createQuickPick();
+            quickPick.title = config.title;
+            if (config.step && config.step > 1) {
+                quickPick.buttons = [vscode_1.QuickInputButtons.Back];
+            }
+            quickPick.placeholder = config.placeholder
+                ? config.placeholder + this.localizer.multiSelectKeyboardPlaceholder()
+                : this.localizer.multiSelectKeyboardPlaceholder();
+            quickPick.ignoreFocusOut = true;
+            quickPick.matchOnDescription = true;
+            quickPick.matchOnDetail = true;
+            quickPick.canSelectMany = true;
+            const preIds = new Set();
+            return await new Promise((resolve) => {
+                let options = [];
+                let isSkip = false;
+                let defaultValue = [];
+                const optionMap = new Map();
+                const loadDynamicData = async () => {
+                    quickPick.busy = true;
+                    quickPick.placeholder = this.localizer.loadingOptionsPlaceholder();
+                    try {
+                        if (typeof config.options === "function") {
+                            options = await config.options();
+                        }
+                        else {
+                            options = config.options;
+                        }
+                        if (typeof config.default === "function") {
+                            defaultValue = await config.default();
+                        }
+                        else {
+                            defaultValue = config.default || [];
+                        }
+                    }
+                    catch (e) {
+                        resolve(teamsfx_api_1.err(this.assembleError(e)));
+                    }
+                };
+                const onDidAccept = async () => {
+                    const strArray = Array.from(quickPick.selectedItems.map((i) => i.id));
+                    if (config.validation) {
+                        const validateRes = await config.validation(strArray);
+                        if (validateRes) {
+                            void this.showMessage("error", validateRes, false);
+                            return;
+                        }
+                    }
+                    let result = strArray;
+                    if (typeof options[0] === "string" ||
+                        config.returnObject === undefined ||
+                        config.returnObject === false)
+                        result = strArray;
+                    else
+                        result = quickPick.selectedItems.map((i) => getOptionItem(i));
+                    resolve(teamsfx_api_1.ok({ type: isSkip ? "skip" : "success", result: result }));
+                };
+                const onDataLoaded = () => {
+                    quickPick.busy = false;
+                    quickPick.placeholder = config.placeholder;
+                    quickPick.items = convertToFxQuickPickItems(options);
+                    for (const item of quickPick.items) {
+                        optionMap.set(item.id, item);
+                    }
+                    if (config.skipSingleOption && options.length === 1) {
+                        quickPick.selectedItems = [quickPick.items[0]];
+                        isSkip = true;
+                        void onDidAccept();
+                        return;
+                    }
+                    if (defaultValue) {
+                        const selectedItems = [];
+                        preIds.clear();
+                        for (const id of defaultValue) {
+                            const item = optionMap.get(id);
+                            if (item) {
+                                selectedItems.push(item);
+                                preIds.add(id);
+                            }
+                        }
+                        quickPick.selectedItems = selectedItems;
+                    }
+                };
+                disposables.push(quickPick.onDidAccept(onDidAccept), quickPick.onDidHide(() => {
+                    resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                }), quickPick.onDidTriggerButton(async (button) => {
+                    if (button === vscode_1.QuickInputButtons.Back)
+                        resolve(teamsfx_api_1.ok({ type: "back" }));
+                    else {
+                        await onDidAccept();
+                    }
+                }));
+                if (config.onDidChangeSelection) {
+                    const changeHandler = async function (items) {
+                        let currentIds = new Set();
+                        for (const item of items) {
+                            currentIds.add(item.id);
+                        }
+                        if (config.onDidChangeSelection) {
+                            const currentClone = cloneSet(currentIds);
+                            currentIds = await config.onDidChangeSelection(currentIds, preIds);
+                            const selectedItems = [];
+                            preIds.clear();
+                            for (const id of currentIds) {
+                                const item = optionMap.get(id);
+                                if (item) {
+                                    selectedItems.push(item);
+                                    preIds.add(id);
+                                }
+                            }
+                            if (!isSame(currentClone, currentIds)) {
+                                quickPick.selectedItems = selectedItems;
+                            }
+                        }
+                    };
+                    disposables.push(quickPick.onDidChangeSelection(changeHandler));
+                }
+                disposables.push(quickPick);
+                if (typeof config.options === "function" || typeof config.default === "function") {
+                    // try to load dynamic data in a very short time
+                    const timeoutPromise = new Promise((resolve) => {
+                        setTimeout(resolve, 500, this.localizer.loadingOptionsTimeoutMessage());
+                    });
+                    Promise.race([loadDynamicData(), timeoutPromise])
+                        .then((value) => {
+                        if (value != this.localizer.loadingOptionsTimeoutMessage()) {
+                            if (config.skipSingleOption && options.length === 1) {
+                                quickPick.items = convertToFxQuickPickItems(options);
+                                quickPick.selectedItems = [quickPick.items[0]];
+                                isSkip = true;
+                                void onDidAccept();
+                                return;
+                            }
+                            else {
+                                onDataLoaded();
+                                quickPick.show();
+                            }
+                        }
+                        else {
+                            quickPick.show();
+                            loadDynamicData()
+                                .then(onDataLoaded)
+                                .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                        }
+                    })
+                        .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                }
+                else {
+                    options = config.options;
+                    defaultValue = config.default;
+                    onDataLoaded();
+                    quickPick.show();
+                }
+            });
+        }
+        finally {
+            disposables.forEach((d) => {
+                d.dispose();
+            });
+        }
+    }
+    async inputText(config) {
+        const disposables = [];
+        try {
+            const inputBox = vscode_1.window.createInputBox();
+            inputBox.title = config.title;
+            if (config.step && config.step > 1) {
+                inputBox.buttons = [vscode_1.QuickInputButtons.Back];
+            }
+            inputBox.ignoreFocusOut = true;
+            inputBox.password = config.password === true;
+            inputBox.prompt = config.prompt;
+            return await new Promise((resolve) => {
+                let defaultValue = undefined;
+                const loadDynamicData = async () => {
+                    try {
+                        if (typeof config.default === "function") {
+                            defaultValue = await config.default();
+                        }
+                    }
+                    catch (e) {
+                        resolve(teamsfx_api_1.err(this.assembleError(e)));
+                    }
+                };
+                const onDataLoaded = () => {
+                    inputBox.busy = false;
+                    inputBox.enabled = true;
+                    inputBox.placeholder = config.placeholder;
+                    inputBox.value = defaultValue || "";
+                };
+                const onDidAccept = async () => {
+                    const validationRes = config.validation
+                        ? await config.validation(inputBox.value)
+                        : undefined;
+                    if (!validationRes) {
+                        inputBox.enabled = false;
+                        inputBox.busy = true;
+                        if (config.additionalValidationOnAccept) {
+                            const oldValue = inputBox.value;
+                            inputBox.placeholder = "Validating...";
+                            inputBox.value = "";
+                            try {
+                                const additionalValidationOnAcceptRes = await config.additionalValidationOnAccept(oldValue);
+                                if (!additionalValidationOnAcceptRes) {
+                                    resolve(teamsfx_api_1.ok({ type: "success", result: oldValue }));
+                                }
+                                else {
+                                    inputBox.validationMessage = additionalValidationOnAcceptRes;
+                                    inputBox.busy = false;
+                                    inputBox.enabled = true;
+                                    inputBox.value = oldValue;
+                                    return;
+                                }
+                            }
+                            catch (e) {
+                                resolve(teamsfx_api_1.err(this.assembleError(e)));
+                            }
+                        }
+                        else {
+                            resolve(teamsfx_api_1.ok({ type: "success", result: inputBox.value }));
+                        }
+                        resolve(teamsfx_api_1.ok({ type: "success", result: inputBox.value }));
+                    }
+                    else {
+                        inputBox.validationMessage = validationRes;
+                    }
+                };
+                if (typeof config.default === "function") {
+                    inputBox.busy = true;
+                    inputBox.enabled = false;
+                    inputBox.placeholder = this.localizer.loadingDefaultPlaceholder();
+                    loadDynamicData()
+                        .then(onDataLoaded)
+                        .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                }
+                else {
+                    defaultValue = config.default || "";
+                    onDataLoaded();
+                }
+                disposables.push(inputBox.onDidChangeValue(async (text) => {
+                    if (config.validation) {
+                        const validationRes = config.validation ? await config.validation(text) : undefined;
+                        if (!!validationRes) {
+                            inputBox.validationMessage = validationRes;
+                        }
+                        else {
+                            inputBox.validationMessage = undefined;
+                        }
+                    }
+                }), inputBox.onDidAccept(onDidAccept), inputBox.onDidHide(() => {
+                    resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                }), inputBox.onDidTriggerButton(async (button) => {
+                    if (button === vscode_1.QuickInputButtons.Back)
+                        resolve(teamsfx_api_1.ok({ type: "back" }));
+                    else {
+                        await onDidAccept();
+                    }
+                }));
+                disposables.push(inputBox);
+                inputBox.show();
+            });
+        }
+        finally {
+            disposables.forEach((d) => {
+                d.dispose();
+            });
+        }
+    }
+    async selectFolder(config) {
+        const disposables = [];
+        try {
+            const quickPick = vscode_1.window.createQuickPick();
+            quickPick.title = config.title;
+            if (config.step && config.step > 1) {
+                quickPick.buttons = [vscode_1.QuickInputButtons.Back];
+            }
+            quickPick.placeholder = config.placeholder;
+            quickPick.ignoreFocusOut = true;
+            quickPick.matchOnDescription = true;
+            quickPick.matchOnDetail = true;
+            quickPick.canSelectMany = false;
+            return await new Promise((resolve) => {
+                let defaultValue = undefined;
+                const loadDynamicData = async () => {
+                    try {
+                        if (typeof config.default === "function") {
+                            defaultValue = await config.default();
+                        }
+                    }
+                    catch (e) {
+                        resolve(teamsfx_api_1.err(this.assembleError(e)));
+                    }
+                };
+                const onDataLoaded = () => {
+                    quickPick.busy = false;
+                    quickPick.placeholder = config.placeholder;
+                    quickPick.items = [
+                        ...(defaultValue
+                            ? [
+                                {
+                                    id: "default",
+                                    label: this.localizer.defaultFolder(),
+                                    description: defaultValue,
+                                },
+                            ]
+                            : []),
+                        {
+                            id: "browse",
+                            label: `$(folder) ${this.localizer.browse()}`,
+                        },
+                    ];
+                };
+                if (typeof config.default === "function") {
+                    quickPick.busy = true;
+                    quickPick.placeholder = this.localizer.loadingDefaultPlaceholder();
+                    loadDynamicData()
+                        .then(onDataLoaded)
+                        .catch((e) => resolve(teamsfx_api_1.err(this.assembleError(e))));
+                }
+                else {
+                    defaultValue = config.default;
+                    onDataLoaded();
+                }
+                let hideByDialog = false;
+                const onDidAccept = async () => {
+                    const selectedItems = quickPick.selectedItems;
+                    if (selectedItems && selectedItems.length > 0) {
+                        const item = selectedItems[0];
+                        if (item.id === "default") {
+                            resolve(teamsfx_api_1.ok({ type: "success", result: defaultValue }));
+                        }
+                        else {
+                            hideByDialog = true;
+                            const uriList = await vscode_1.window.showOpenDialog({
+                                defaultUri: defaultValue ? vscode_1.Uri.file(defaultValue) : undefined,
+                                canSelectFiles: false,
+                                canSelectFolders: true,
+                                canSelectMany: false,
+                                title: config.title,
+                            });
+                            if (uriList && uriList.length > 0) {
+                                const result = uriList[0].fsPath;
+                                resolve(teamsfx_api_1.ok({ type: "success", result: result }));
+                            }
+                            else {
+                                resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                            }
+                        }
+                    }
+                };
+                disposables.push(quickPick.onDidAccept(onDidAccept), quickPick.onDidHide(() => {
+                    if (!hideByDialog) {
+                        resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                    }
+                }), quickPick.onDidTriggerButton((button) => {
+                    if (button === vscode_1.QuickInputButtons.Back)
+                        resolve(teamsfx_api_1.ok({ type: "back" }));
+                }));
+                disposables.push(quickPick);
+                quickPick.show();
+            });
+        }
+        finally {
+            disposables.forEach((d) => {
+                d.dispose();
+            });
+        }
+    }
+    async selectFile(config) {
+        if (config.default && typeof config.default === "function") {
+            //TODO quick workaround solution, which will blocking the UI popup
+            config.default = await config.default();
+        }
+        return this.selectFileInQuickPick(config, "file", config.default);
+    }
+    async selectFiles(config) {
+        if (config.default && typeof config.default === "function") {
+            //TODO  quick workaround solution, which will blocking the UI popup
+            config.default = await config.default();
+        }
+        return this.selectFileInQuickPick(config, "files", config.default ? config.default.join(";") : undefined);
+    }
+    async selectFileInQuickPick(config, type, defaultValue) {
+        if (config.possibleFiles) {
+            if (config.possibleFiles.find((o) => o.id === "browse" || o.id === "default")) {
+                return Promise.resolve(teamsfx_api_1.err(new teamsfx_api_1.SystemError("UI", "InvalidInput", 'Possible files should not contain item with id "browse" or "default".')));
+            }
+        }
+        /// TODO: use generic constraints.
+        const disposables = [];
+        try {
+            const quickPick = vscode_1.window.createQuickPick();
+            quickPick.title = config.title;
+            if (config.step && config.step > 1) {
+                quickPick.buttons = [vscode_1.QuickInputButtons.Back];
+            }
+            quickPick.ignoreFocusOut = true;
+            quickPick.placeholder = config.placeholder;
+            quickPick.matchOnDescription = false;
+            quickPick.matchOnDetail = false;
+            quickPick.canSelectMany = false;
+            let fileSelectorIsOpen = false;
+            return await new Promise((resolve) => {
+                // set options
+                quickPick.items = [
+                    ...(config.possibleFiles
+                        ? config.possibleFiles
+                        : defaultValue
+                            ? [
+                                {
+                                    id: "default",
+                                    label: `$(file) ${path.basename(defaultValue)}`,
+                                    description: path.dirname(defaultValue),
+                                },
+                            ]
+                            : []),
+                    {
+                        id: "browse",
+                        label: `$(file) ${this.localizer.browse()}`,
+                    },
+                ];
+                const onDidAccept = async () => {
+                    var _a, _b;
+                    const selectedItems = quickPick.selectedItems;
+                    let result;
+                    if (selectedItems && selectedItems.length > 0) {
+                        const item = selectedItems[0];
+                        if (item.id === "default") {
+                            result = config.default;
+                        }
+                        else if (item.id === "browse") {
+                            fileSelectorIsOpen = true;
+                            const uriList = await vscode_1.window.showOpenDialog({
+                                defaultUri: config.default ? vscode_1.Uri.file(config.default) : undefined,
+                                canSelectFiles: true,
+                                canSelectFolders: false,
+                                canSelectMany: type === "files",
+                                filters: config.filters,
+                                title: config.title,
+                            });
+                            if (uriList && uriList.length > 0) {
+                                if (type === "files") {
+                                    const results = uriList.map((u) => u.fsPath);
+                                    result = results;
+                                }
+                                else {
+                                    result = uriList[0].fsPath;
+                                }
+                            }
+                            else {
+                                quickPick.selectedItems = [];
+                                return;
+                            }
+                        }
+                        else {
+                            result = (_b = (_a = config.possibleFiles) === null || _a === void 0 ? void 0 : _a.find((f) => f.id === item.id)) === null || _b === void 0 ? void 0 : _b.id;
+                        }
+                        if (config.validation && result !== undefined) {
+                            quickPick.busy = true;
+                            quickPick.enabled = false;
+                            try {
+                                const validationResult = await config.validation(result);
+                                quickPick.busy = false;
+                                quickPick.enabled = true;
+                                if (validationResult) {
+                                    void this.showMessage("error", validationResult, false);
+                                    quickPick.selectedItems = [];
+                                    quickPick.activeItems = [];
+                                    return;
+                                }
+                            }
+                            catch (e) {
+                                resolve(teamsfx_api_1.err(this.assembleError(e)));
+                            }
+                        }
+                        resolve(teamsfx_api_1.ok({ type: "success", result: result }));
+                    }
+                };
+                disposables.push(quickPick.onDidAccept(onDidAccept), quickPick.onDidHide(() => {
+                    if (fileSelectorIsOpen === false)
+                        resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                }), quickPick.onDidTriggerButton((button) => {
+                    if (button === vscode_1.QuickInputButtons.Back)
+                        resolve(teamsfx_api_1.ok({ type: "back" }));
+                }));
+                disposables.push(quickPick);
+                quickPick.show();
+            });
+        }
+        finally {
+            disposables.forEach((d) => {
+                d.dispose();
+            });
+        }
+    }
+    async openUrl(link) {
+        const uri = vscode_1.Uri.parse(link);
+        const result = await vscode_1.env.openExternal(uri);
+        if (result) {
+            return teamsfx_api_1.ok(result);
+        }
+        else {
+            return teamsfx_api_1.err(new error_1.InternalUIError(this.localizer.internalErrorMessage(`env.openExternal('${link}')`), this.localizer.internalErrorDisplayMessage(`env.openExternal('${link}')`)));
+        }
+    }
+    async selectFileOrInput(config) {
+        const validtionOnSelect = async (input) => {
+            if (input === config.inputOptionItem.id) {
+                return undefined;
+            }
+            if (config.validation) {
+                return await config.validation(input);
+            }
+        };
+        const selectFileConfig = Object.assign(Object.assign({}, config), { validation: validtionOnSelect, possibleFiles: [config.inputOptionItem] });
+        while (true) {
+            const selectFileOrItemRes = await this.selectFile(selectFileConfig);
+            if (selectFileOrItemRes.isOk()) {
+                if (selectFileOrItemRes.value.result === config.inputOptionItem.id) {
+                    const inputRes = await this.inputText(Object.assign(Object.assign({}, config.inputBoxConfig), { additionalValidationOnAccept: config.validation }));
+                    if (inputRes.isOk()) {
+                        if (inputRes.value.type === "back")
+                            continue;
+                        return teamsfx_api_1.ok(inputRes.value);
+                    }
+                    else {
+                        return teamsfx_api_1.err(inputRes.error);
+                    }
+                }
+                else {
+                    return teamsfx_api_1.ok(selectFileOrItemRes.value);
+                }
+            }
+            else {
+                return teamsfx_api_1.err(selectFileOrItemRes.error);
+            }
+        }
+    }
+    async confirm(config) {
+        var _a;
+        const confirmText = ((_a = config.transformer) === null || _a === void 0 ? void 0 : _a.call(config, true)) || "Confirm";
+        const res = await this.showMessage("warn", config.title, true, confirmText);
+        if (res.isErr()) {
+            return teamsfx_api_1.err(res.error);
+        }
+        const value = res.value;
+        if (value === confirmText)
+            return teamsfx_api_1.ok({ type: "success", result: true });
+        return teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage()));
+    }
+    async showMessage(level, message, modal, ...items) {
+        if (message instanceof Array) {
+            message = message.map((x) => x.content).join("");
+        }
+        return new Promise((resolve) => {
+            const option = { modal: modal };
+            try {
+                let promise;
+                switch (level) {
+                    case "info": {
+                        promise = vscode_1.window.showInformationMessage(message, option, ...items);
+                        break;
+                    }
+                    case "warn": {
+                        promise = vscode_1.window.showWarningMessage(message, option, ...items);
+                        break;
+                    }
+                    case "error":
+                        promise = vscode_1.window.showErrorMessage(message, option, ...items);
+                }
+                promise.then((v) => {
+                    if (v)
+                        resolve(teamsfx_api_1.ok(v));
+                    else
+                        resolve(teamsfx_api_1.err(new error_1.UserCancelError(this.localizer.emptyOptionErrorMessage(), this.localizer.emptyOptionErrorDisplayMessage())));
+                }, (error) => { });
+            }
+            catch (error) {
+                resolve(teamsfx_api_1.err(this.assembleError(error)));
+            }
+        });
+    }
+    createProgressBar(title, totalSteps) {
+        return new progressHandler_1.ProgressHandler(title, totalSteps);
+    }
+    async executeFunction(config) {
+        const quickPick = vscode_1.window.createQuickPick();
+        quickPick.title = config.title;
+        quickPick.busy = true;
+        quickPick.enabled = false;
+        quickPick.show();
+        try {
+            return (await config.func(config.inputs));
+        }
+        finally {
+            quickPick.hide();
+            quickPick.dispose();
+        }
+    }
+    async runCommand(args) {
+        var _a, _b;
+        const cmd = args.cmd;
+        const workingDirectory = args.workingDirectory;
+        const shell = args.shell;
+        const timeout = args.timeout;
+        const env = args.env;
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            const wait = setTimeout(() => {
+                clearTimeout(wait);
+                reject(new error_1.ScriptTimeoutError(this.localizer.commandTimeoutErrorMessage(cmd), this.localizer.commandTimeoutErrorDisplayMessage(cmd)));
+            }, timeout !== null && timeout !== void 0 ? timeout : 1000 * 60 * 5);
+        });
+        try {
+            let terminal;
+            const name = (_a = args.shellName) !== null && _a !== void 0 ? _a : (shell ? `${this.terminalName}-${shell}` : this.terminalName);
+            if (vscode_1.window.terminals.length === 0 ||
+                (terminal = lodash_1.find(vscode_1.window.terminals, (value) => value.name === name)) === undefined) {
+                terminal = vscode_1.window.createTerminal({
+                    name,
+                    shellPath: shell,
+                    cwd: workingDirectory,
+                    env,
+                    iconPath: args.iconPath ? new vscode_1.ThemeIcon(args.iconPath) : undefined,
+                });
+            }
+            terminal.show();
+            terminal.sendText(cmd);
+            const processId = await Promise.race([terminal.processId, timeoutPromise]);
+            await sleep(500);
+            return teamsfx_api_1.ok((_b = processId === null || processId === void 0 ? void 0 : processId.toString()) !== null && _b !== void 0 ? _b : "");
+        }
+        catch (error) {
+            return teamsfx_api_1.err(this.assembleError(error));
+        }
+    }
+    async openFile(filePath) {
+        const uri = vscode_1.Uri.file(filePath);
+        const doc = await vscode_1.workspace.openTextDocument(uri);
+        if (doc) {
+            if (filePath.endsWith(".md")) {
+                await vscode_1.commands.executeCommand("markdown.showPreview", uri);
+            }
+            else {
+                await vscode_1.window.showTextDocument(doc);
+            }
+            return teamsfx_api_1.ok(true);
+        }
+        else {
+            return teamsfx_api_1.err(new error_1.InternalUIError(this.localizer.internalErrorMessage(`workspace.openTextDocument('${filePath}')`), this.localizer.internalErrorDisplayMessage(`workspace.openTextDocument('${filePath}')`)));
+        }
+    }
+}
+exports.VSCodeUI = VSCodeUI;
+//# sourceMappingURL=ui.js.map