@microsoft/inshellisense 0.0.1-rc.3 → 0.0.1-rc.31

package/build/runtime/runtime.js

@@ -1,224 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import speclist, { diffVersionedCompletions as versionedSpeclist,
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
- } from "@withfig/autocomplete/build/index.js";
-import { parseCommand } from "./parser.js";
-import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
-import { buildExecuteShellCommand } from "./utils.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- recursive type, setting as any
-const specSet = {};
-speclist.forEach((s) => {
-    let activeSet = specSet;
-    const specRoutes = s.split("/");
-    specRoutes.forEach((route, idx) => {
-        if (idx === specRoutes.length - 1) {
-            const prefix = versionedSpeclist.includes(s) ? "/index.js" : `.js`;
-            activeSet[route] = `@withfig/autocomplete/build/${s}${prefix}`;
-        }
-        else {
-            activeSet[route] = activeSet[route] || {};
-            activeSet = activeSet[route];
-        }
-    });
-});
-const loadedSpecs = {};
-const loadSpec = async (cmd) => {
-    const rootToken = cmd.at(0);
-    if (!rootToken?.complete) {
-        return;
-    }
-    if (loadedSpecs[rootToken.token]) {
-        return loadedSpecs[rootToken.token];
-    }
-    if (specSet[rootToken.token]) {
-        const spec = (await import(specSet[rootToken.token])).default;
-        loadedSpecs[rootToken.token] = spec;
-        return spec;
-    }
-};
-// this load spec function should only be used for `loadSpec` on the fly as it is cacheless
-const lazyLoadSpec = async (key) => {
-    return (await import(`@withfig/autocomplete/build/${key}.js`)).default;
-};
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- will be implemented in below TODO
-const lazyLoadSpecLocation = async (location) => {
-    return; //TODO: implement spec location loading
-};
-export const getSuggestions = async (cmd) => {
-    const activeCmd = parseCommand(cmd);
-    const rootToken = activeCmd.at(0);
-    if (activeCmd.length === 0 || !rootToken?.complete) {
-        return;
-    }
-    const spec = await loadSpec(activeCmd);
-    if (spec == null)
-        return;
-    const subcommand = getSubcommand(spec);
-    if (subcommand == null)
-        return;
-    const result = await runSubcommand(activeCmd.slice(1), subcommand);
-    if (result == null)
-        return;
-    const lastCommand = activeCmd.at(-1);
-    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
-    return { ...result, charactersToDrop };
-};
-const getPersistentOptions = (persistentOptions, options) => {
-    const persistentOptionNames = new Set(persistentOptions.map((o) => (typeof o.name === "string" ? [o.name] : o.name)).flat());
-    return persistentOptions.concat((options ?? []).filter((o) => (typeof o.name == "string" ? !persistentOptionNames.has(o.name) : o.name.some((n) => !persistentOptionNames.has(n))) && o.isPersistent === true));
-};
-// TODO: handle subcommands that are versioned
-const getSubcommand = (spec) => {
-    if (spec == null)
-        return;
-    if (typeof spec === "function") {
-        const potentialSubcommand = spec();
-        if (Object.prototype.hasOwnProperty.call(potentialSubcommand, "name")) {
-            return potentialSubcommand;
-        }
-        return;
-    }
-    return spec;
-};
-const executeShellCommand = buildExecuteShellCommand(5000);
-const genSubcommand = async (command, parentCommand) => {
-    const subcommandIdx = parentCommand.subcommands?.findIndex((s) => s.name === command);
-    if (subcommandIdx == null)
-        return;
-    const subcommand = parentCommand.subcommands?.at(subcommandIdx);
-    if (subcommand == null)
-        return;
-    // this pulls in the spec from the load spec and overwrites the subcommand in the parent with the loaded spec.
-    // then it returns the subcommand and clears the loadSpec field so that it doesn't get called again
-    switch (typeof subcommand.loadSpec) {
-        case "function": {
-            const partSpec = await subcommand.loadSpec(command, executeShellCommand);
-            if (partSpec instanceof Array) {
-                const locationSpecs = (await Promise.all(partSpec.map((s) => lazyLoadSpecLocation(s)))).filter((s) => s != null);
-                const subcommands = locationSpecs.map((s) => getSubcommand(s)).filter((s) => s != null);
-                parentCommand.subcommands[subcommandIdx] = {
-                    ...subcommand,
-                    ...(subcommands.find((s) => s?.name == command) ?? []),
-                    loadSpec: undefined,
-                };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-            else if (Object.prototype.hasOwnProperty.call(partSpec, "type")) {
-                const locationSingleSpec = await lazyLoadSpecLocation(partSpec);
-                parentCommand.subcommands[subcommandIdx] = {
-                    ...subcommand,
-                    ...(getSubcommand(locationSingleSpec) ?? []),
-                    loadSpec: undefined,
-                };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-            else {
-                parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...partSpec, loadSpec: undefined };
-                return parentCommand.subcommands[subcommandIdx];
-            }
-        }
-        case "string": {
-            const spec = await lazyLoadSpec(subcommand.loadSpec);
-            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(getSubcommand(spec) ?? []), loadSpec: undefined };
-            return parentCommand.subcommands[subcommandIdx];
-        }
-        case "object": {
-            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(subcommand.loadSpec ?? {}), loadSpec: undefined };
-            return parentCommand.subcommands[subcommandIdx];
-        }
-        case "undefined": {
-            return subcommand;
-        }
-    }
-};
-const getOption = (activeToken, options) => {
-    return options.find((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
-};
-const getPersistentTokens = (tokens) => {
-    return tokens.filter((t) => t.isPersistent === true);
-};
-const getArgs = (args) => {
-    return args instanceof Array ? args : args != null ? [args] : [];
-};
-const runOption = async (tokens, option, subcommand, persistentOptions, acceptedTokens) => {
-    if (tokens.length === 0) {
-        throw new Error("invalid state reached, option expected but no tokens found");
-    }
-    const activeToken = tokens[0];
-    const isPersistent = persistentOptions.some((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
-    if ((option.args instanceof Array && option.args.length > 0) || option.args != null) {
-        const args = option.args instanceof Array ? option.args : [option.args];
-        return runArg(tokens.slice(1), args, subcommand, persistentOptions, acceptedTokens.concat(activeToken), true, false);
-    }
-    return runSubcommand(tokens.slice(1), subcommand, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
-};
-const runArg = async (tokens, args, subcommand, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
-    if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, persistentOptions, acceptedTokens, true, !fromOption);
-    }
-    else if (tokens.length === 0) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic);
-    }
-    else if (!tokens.at(0)?.complete) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0].token, acceptedTokens, fromVariadic);
-    }
-    const activeToken = tokens[0];
-    if (args.every((a) => a.isOptional)) {
-        if (activeToken.isOption) {
-            const option = getOption(activeToken, persistentOptions.concat(subcommand.options ?? []));
-            if (option != null) {
-                return runOption(tokens, option, subcommand, persistentOptions, acceptedTokens);
-            }
-            return;
-        }
-        const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
-        if (nextSubcommand != null) {
-            return runSubcommand(tokens.slice(1), nextSubcommand, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
-        }
-    }
-    const activeArg = args[0];
-    if (activeArg.isVariadic) {
-        return runArg(tokens.slice(1), args, subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
-    }
-    else if (activeArg.isCommand) {
-        if (tokens.length <= 0) {
-            return;
-        }
-        const spec = await loadSpec(tokens);
-        if (spec == null)
-            return;
-        const subcommand = getSubcommand(spec);
-        if (subcommand == null)
-            return;
-        return runSubcommand(tokens.slice(1), subcommand);
-    }
-    return runArg(tokens.slice(1), args.slice(1), subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
-};
-const runSubcommand = async (tokens, subcommand, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
-    if (tokens.length === 0) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens);
-    }
-    else if (!tokens.at(0)?.complete) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0].token, argsDepleted, argsUsed, acceptedTokens);
-    }
-    const activeToken = tokens[0];
-    const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
-    const allOptions = [...persistentOptions, ...(subcommand.options ?? [])];
-    if (activeToken.isOption) {
-        const option = getOption(activeToken, allOptions);
-        if (option != null) {
-            return runOption(tokens, option, subcommand, persistentOptions, acceptedTokens);
-        }
-        return;
-    }
-    const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
-    if (nextSubcommand != null) {
-        return runSubcommand(tokens.slice(1), nextSubcommand, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
-    }
-    if (activeArgsLength <= 0) {
-        return; // not subcommand or option & no args exist
-    }
-    return runArg(tokens, getArgs(subcommand.args), subcommand, allOptions, acceptedTokens, false, false);
-};

package/build/runtime/suggestion.js

@@ -1,184 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { runGenerator } from "./generator.js";
-import { runTemplates } from "./template.js";
-var SuggestionIcons;
-(function (SuggestionIcons) {
-    SuggestionIcons["File"] = "\uD83D\uDCC4";
-    SuggestionIcons["Folder"] = "\uD83D\uDCC1";
-    SuggestionIcons["Subcommand"] = "\uD83D\uDCE6";
-    SuggestionIcons["Option"] = "\uD83D\uDD17";
-    SuggestionIcons["Argument"] = "\uD83D\uDCB2";
-    SuggestionIcons["Mixin"] = "\uD83C\uDFDD\uFE0F";
-    SuggestionIcons["Shortcut"] = "\uD83D\uDD25";
-    SuggestionIcons["Special"] = "\u2B50";
-    SuggestionIcons["Default"] = "\uD83D\uDCC0";
-})(SuggestionIcons || (SuggestionIcons = {}));
-const getIcon = (suggestionType) => {
-    switch (suggestionType) {
-        case "arg":
-            return SuggestionIcons.Argument;
-        case "file":
-            return SuggestionIcons.File;
-        case "folder":
-            return SuggestionIcons.Folder;
-        case "option":
-            return SuggestionIcons.Option;
-        case "subcommand":
-            return SuggestionIcons.Subcommand;
-        case "mixin":
-            return SuggestionIcons.Mixin;
-        case "shortcut":
-            return SuggestionIcons.Shortcut;
-        case "special":
-            return SuggestionIcons.Special;
-    }
-    return SuggestionIcons.Default;
-};
-const getLong = (suggestion) => {
-    return suggestion instanceof Array ? suggestion.reduce((p, c) => (p.length > c.length ? p : c)) : suggestion;
-};
-const toSuggestion = (suggestion, name, type) => {
-    if (suggestion.name == null)
-        return;
-    return {
-        name: name ?? getLong(suggestion.name),
-        description: suggestion.description,
-        icon: getIcon(type ?? suggestion.type),
-        allNames: suggestion.name instanceof Array ? suggestion.name : [suggestion.name],
-        priority: suggestion.priority ?? 50,
-        insertValue: suggestion.insertValue,
-    };
-};
-function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
-    if (!partialCmd)
-        return suggestions.map((s) => toSuggestion(s, undefined, suggestionType)).filter((s) => s != null);
-    switch (filterStrategy) {
-        case "fuzzy":
-            return suggestions
-                .map((s) => {
-                if (s.name == null)
-                    return;
-                if (s.name instanceof Array) {
-                    const matchedName = s.name.find((n) => n.toLowerCase().includes(partialCmd.toLowerCase()));
-                    return matchedName != null
-                        ? {
-                            name: matchedName,
-                            description: s.description,
-                            icon: getIcon(s.type ?? suggestionType),
-                            allNames: s.name,
-                            priority: s.priority ?? 50,
-                            insertValue: s.insertValue,
-                        }
-                        : undefined;
-                }
-                return s.name.toLowerCase().includes(partialCmd.toLowerCase())
-                    ? {
-                        name: s.name,
-                        description: s.description,
-                        icon: getIcon(s.type ?? suggestionType),
-                        allNames: [s.name],
-                        priority: s.priority ?? 50,
-                        insertValue: s.insertValue,
-                    }
-                    : undefined;
-            })
-                .filter((s) => s != null);
-        default:
-            return suggestions
-                .map((s) => {
-                if (s.name == null)
-                    return;
-                if (s.name instanceof Array) {
-                    const matchedName = s.name.find((n) => n.toLowerCase().startsWith(partialCmd.toLowerCase()));
-                    return matchedName != null
-                        ? {
-                            name: matchedName,
-                            description: s.description,
-                            icon: getIcon(s.type ?? suggestionType),
-                            allNames: s.name,
-                            insertValue: s.insertValue,
-                            priority: s.priority ?? 50,
-                        }
-                        : undefined;
-                }
-                return s.name.toLowerCase().startsWith(partialCmd.toLowerCase())
-                    ? {
-                        name: s.name,
-                        description: s.description,
-                        icon: getIcon(s.type ?? suggestionType),
-                        allNames: [s.name],
-                        insertValue: s.insertValue,
-                        priority: s.priority ?? 50,
-                    }
-                    : undefined;
-            })
-                .filter((s) => s != null);
-    }
-}
-const generatorSuggestions = async (generator, acceptedTokens, filterStrategy, partialCmd) => {
-    const generators = generator instanceof Array ? generator : generator ? [generator] : [];
-    const tokens = acceptedTokens.map((t) => t.token);
-    const suggestions = (await Promise.all(generators.map((gen) => runGenerator(gen, tokens)))).flat();
-    return filter(suggestions, filterStrategy, partialCmd, undefined);
-};
-const templateSuggestions = async (templates, filterStrategy, partialCmd) => {
-    return filter(await runTemplates(templates ?? []), filterStrategy, partialCmd, undefined);
-};
-const suggestionSuggestions = (suggestions, filterStrategy, partialCmd) => {
-    const cleanedSuggestions = suggestions?.map((s) => (typeof s === "string" ? { name: s } : s)) ?? [];
-    return filter(cleanedSuggestions ?? [], filterStrategy, partialCmd, undefined);
-};
-const subcommandSuggestions = (subcommands, filterStrategy, partialCmd) => {
-    return filter(subcommands ?? [], filterStrategy, partialCmd, "subcommand");
-};
-const optionSuggestions = (options, acceptedTokens, filterStrategy, partialCmd) => {
-    const usedOptions = new Set(acceptedTokens.filter((t) => t.isOption).map((t) => t.token));
-    const validOptions = options?.filter((o) => o.exclusiveOn?.every((exclusiveOption) => !usedOptions.has(exclusiveOption)) ?? true);
-    return filter(validOptions ?? [], filterStrategy, partialCmd, "option");
-};
-const removeDuplicateSuggestions = (suggestions, acceptedTokens) => {
-    const seen = new Set(acceptedTokens.map((t) => t.token));
-    return suggestions.filter((s) => s.allNames.every((n) => !seen.has(n)));
-};
-const removeEmptySuggestion = (suggestions) => {
-    return suggestions.filter((s) => s.name.length > 0);
-};
-export const getSubcommandDrivenRecommendation = async (subcommand, persistentOptions, partialCmd, argsDepleted, argsFromSubcommand, acceptedTokens) => {
-    if (argsDepleted && argsFromSubcommand) {
-        return;
-    }
-    const suggestions = [];
-    const argLength = subcommand.args instanceof Array ? subcommand.args.length : subcommand.args ? 1 : 0;
-    const allOptions = persistentOptions.concat(subcommand.options ?? []);
-    if (!argsFromSubcommand) {
-        suggestions.push(...subcommandSuggestions(subcommand.subcommands, subcommand.filterStrategy, partialCmd));
-        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, subcommand.filterStrategy, partialCmd));
-    }
-    if (argLength != 0) {
-        const activeArg = subcommand.args instanceof Array ? subcommand.args[0] : subcommand.args;
-        suggestions.push(...(await generatorSuggestions(activeArg?.generators, acceptedTokens, activeArg?.filterStrategy, partialCmd)));
-        suggestions.push(...suggestionSuggestions(activeArg?.suggestions, activeArg?.filterStrategy, partialCmd));
-        suggestions.push(...(await templateSuggestions(activeArg?.template, activeArg?.filterStrategy, partialCmd)));
-    }
-    return {
-        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
-    };
-};
-export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialCmd, acceptedTokens, variadicArgBound) => {
-    const activeArg = args[0];
-    const allOptions = persistentOptions.concat(subcommand.options ?? []);
-    const suggestions = [
-        ...(await generatorSuggestions(args[0].generators, acceptedTokens, activeArg?.filterStrategy, partialCmd)),
-        ...suggestionSuggestions(args[0].suggestions, activeArg?.filterStrategy, partialCmd),
-        ...(await templateSuggestions(args[0].template, activeArg?.filterStrategy, partialCmd)),
-    ];
-    if ((activeArg.isOptional && !activeArg.isVariadic) || (activeArg.isVariadic && activeArg.isOptional && !variadicArgBound)) {
-        suggestions.push(...subcommandSuggestions(subcommand.subcommands, activeArg?.filterStrategy, partialCmd));
-        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, activeArg?.filterStrategy, partialCmd));
-    }
-    return {
-        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
-        argumentDescription: activeArg.description ?? activeArg.name,
-    };
-};

package/build/runtime/template.js

@@ -1,35 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import fsAsync from "fs/promises";
-import process from "node:process";
-const filepathsTemplate = async () => {
-    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
-    return files.filter((f) => f.isFile() || f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
-};
-const foldersTemplate = async () => {
-    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
-    return files.filter((f) => f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
-};
-// TODO: implement history template
-const historyTemplate = () => {
-    return [];
-};
-// TODO: implement help template
-const helpTemplate = () => {
-    return [];
-};
-export const runTemplates = async (template) => {
-    const templates = template instanceof Array ? template : [template];
-    return (await Promise.all(templates.map(async (t) => {
-        switch (t) {
-            case "filepaths":
-                return await filepathsTemplate();
-            case "folders":
-                return await foldersTemplate();
-            case "history":
-                return historyTemplate();
-            case "help":
-                return helpTemplate();
-        }
-    }))).flat();
-};

package/build/runtime/utils.js

@@ -1,22 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { exec, spawn } from "node:child_process";
-export const buildExecuteShellCommand = (timeout) => 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO: use cwd in the future
-async (command, cwd) => {
-    return new Promise((resolve) => {
-        exec(command, { timeout }, (_, stdout, stderr) => {
-            resolve(stdout || stderr);
-        });
-    });
-};
-export const executeShellCommandTTY = async (shell, command) => {
-    const child = spawn(shell, ["-c", command.trim()], { stdio: "inherit" });
-    return new Promise((resolve) => {
-        child.on("close", (code) => {
-            resolve({
-                code,
-            });
-        });
-    });
-};

package/build/ui/input.js

@@ -1,55 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useState, useEffect } from "react";
-import { useInput, Text } from "ink";
-import chalk from "chalk";
-const BlinkSpeed = 530;
-const CursorColor = "#FFFFFF";
-export default function Input({ value, setValue, prompt, activeSuggestion, tabCompletionDropSize, }) {
-    const [cursorLocation, setCursorLocation] = useState(value.length);
-    const [cursorBlink, setCursorBlink] = useState(true);
-    useEffect(() => {
-        setTimeout(() => {
-            setCursorBlink(!cursorBlink);
-        }, BlinkSpeed);
-    }, [cursorBlink]);
-    // TODO: arrow key navigation shortcuts (emacs & vim modes)
-    useInput((input, key) => {
-        // TODO: handle delete better on unix systems: https://github.com/vadimdemedes/ink/issues/634
-        const windows = process.platform === "win32";
-        const backspaceKey = windows ? key.backspace : key.backspace || key.delete;
-        const deleteKey = windows ? key.delete : false;
-        if (backspaceKey) {
-            setValue([...value].slice(0, Math.max(cursorLocation - 1, 0)).join("") + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (deleteKey) {
-            setValue([...value].slice(0, cursorLocation).join("") + [...value].slice(Math.min(value.length, cursorLocation + 1)).join(""));
-        }
-        else if (key.leftArrow) {
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (key.rightArrow) {
-            setCursorLocation(Math.min(cursorLocation + 1, value.length));
-        }
-        else if (key.tab) {
-            if (activeSuggestion) {
-                // TOOD: support insertValue
-                const newValue = [...value].slice(0, cursorLocation - tabCompletionDropSize).join("") + activeSuggestion.name + " ";
-                setValue(newValue);
-                setCursorLocation(newValue.length);
-            }
-        }
-        else if (input) {
-            setValue([...value].slice(0, cursorLocation).join("") + input + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(cursorLocation + input.length);
-        }
-    });
-    const cursoredCommand = value + " ";
-    const cursoredText = [...cursoredCommand].slice(0, cursorLocation).join("") +
-        (cursorBlink ? chalk.bgHex(CursorColor).inverse([...cursoredCommand].at(cursorLocation)) : [...cursoredCommand].at(cursorLocation)) +
-        [...cursoredCommand].slice(cursorLocation + 1).join("");
-    return (React.createElement(Text, null,
-        prompt,
-        cursoredText));
-}

package/build/ui/suggestions.js

@@ -1,84 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useState, useCallback, useEffect } from "react";
-import { Text, useInput, Box, measureElement } from "ink";
-import wrapAnsi from "wrap-ansi";
-const MaxSuggestions = 5;
-const SuggestionWidth = 40;
-const DescriptionWidth = 30;
-const DescriptionMaxHeight = 6;
-const BorderWidth = 2;
-const ActiveSuggestionBackgroundColor = "#7D56F4";
-function Description({ description }) {
-    wrapAnsi(description, DescriptionWidth, { hard: true });
-    if (description.length !== 0) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { borderStyle: "single", width: DescriptionWidth },
-                React.createElement(Text, null, truncateDescription(description, DescriptionMaxHeight)))));
-    }
-}
-function truncateDescription(description, maxHeight) {
-    const wrappedText = wrapAnsi(description, DescriptionWidth - BorderWidth, {
-        trim: false,
-        hard: true,
-    });
-    const lines = wrappedText.split("\n");
-    const truncatedLines = lines.slice(0, maxHeight);
-    if (lines.length > maxHeight) {
-        truncatedLines[maxHeight - 1] = [...truncatedLines[maxHeight - 1]].slice(0, -1).join("") + "…";
-    }
-    return truncatedLines.join("\n");
-}
-function SuggestionList({ suggestions, activeSuggestionIdx }) {
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { borderStyle: "single", width: SuggestionWidth, flexDirection: "column" }, suggestions
-            .map((suggestion, idx) => {
-            const bgColor = idx === activeSuggestionIdx ? ActiveSuggestionBackgroundColor : undefined;
-            return (React.createElement(Box, { key: idx },
-                React.createElement(Text, { backgroundColor: bgColor, wrap: "truncate-end" }, `${suggestion.icon} ${suggestion.name}`.padEnd(SuggestionWidth - BorderWidth, " "))));
-        })
-            .filter((node) => node !== undefined))));
-}
-export default function Suggestions({ leftPadding, setActiveSuggestion, suggestions, }) {
-    const [activeSuggestionIndex, setActiveSuggestionIndex] = useState(0);
-    const [windowWidth, setWindowWidth] = useState(500);
-    const page = Math.floor(activeSuggestionIndex / MaxSuggestions) + 1;
-    const pagedSuggestions = suggestions.filter((_, idx) => idx < page * MaxSuggestions && idx >= (page - 1) * MaxSuggestions);
-    const activePagedSuggestionIndex = activeSuggestionIndex % MaxSuggestions;
-    const activeDescription = pagedSuggestions.at(activePagedSuggestionIndex)?.description || "";
-    const wrappedPadding = leftPadding % windowWidth;
-    const maxPadding = activeDescription.length !== 0 ? windowWidth - SuggestionWidth - DescriptionWidth : windowWidth - SuggestionWidth;
-    const swapDescription = wrappedPadding > maxPadding;
-    const swappedPadding = swapDescription ? Math.max(wrappedPadding - DescriptionWidth, 0) : wrappedPadding;
-    const clampedLeftPadding = Math.min(Math.min(wrappedPadding, swappedPadding), maxPadding);
-    useEffect(() => {
-        setActiveSuggestion(suggestions[activeSuggestionIndex]);
-    }, [activeSuggestionIndex, suggestions]);
-    useEffect(() => {
-        if (suggestions.length <= activeSuggestionIndex) {
-            setActiveSuggestionIndex(Math.max(suggestions.length - 1, 0));
-        }
-    }, [suggestions]);
-    useInput((_, key) => {
-        if (key.upArrow) {
-            setActiveSuggestionIndex(Math.max(0, activeSuggestionIndex - 1));
-        }
-        if (key.downArrow) {
-            setActiveSuggestionIndex(Math.min(activeSuggestionIndex + 1, suggestions.length - 1));
-        }
-    });
-    const measureRef = useCallback((node) => {
-        if (node !== null) {
-            const { width } = measureElement(node);
-            setWindowWidth(width);
-        }
-    }, []);
-    if (suggestions.length === 0)
-        return React.createElement(React.Fragment, null);
-    return (React.createElement(Box, { ref: measureRef },
-        React.createElement(Box, { paddingLeft: clampedLeftPadding }, swapDescription ? (React.createElement(React.Fragment, null,
-            React.createElement(Description, { description: activeDescription }),
-            React.createElement(SuggestionList, { suggestions: pagedSuggestions, activeSuggestionIdx: activePagedSuggestionIndex }))) : (React.createElement(React.Fragment, null,
-            React.createElement(SuggestionList, { suggestions: pagedSuggestions, activeSuggestionIdx: activePagedSuggestionIndex }),
-            React.createElement(Description, { description: activeDescription }))))));
-}

package/build/ui/ui-bind.js

@@ -1,69 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useEffect, useState } from "react";
-import { Box, Text, render as inkRender, useInput, useApp } from "ink";
-import chalk from "chalk";
-import { availableBindings, bind, supportedShells } from "../utils/bindings.js";
-let uiResult = "";
-function UI() {
-    const { exit } = useApp();
-    const [selectionIdx, setSelectionIdx] = useState(0);
-    const [loaded, setLoaded] = useState(false);
-    const [availableShells, setAvailableShells] = useState([]);
-    useEffect(() => {
-        availableBindings().then((bindings) => {
-            if (bindings.length == 0) {
-                exit();
-            }
-            setAvailableShells(bindings);
-            setLoaded(true);
-        });
-    }, []);
-    useInput(async (_, key) => {
-        if (key.upArrow) {
-            setSelectionIdx(Math.max(0, selectionIdx - 1));
-        }
-        else if (key.downArrow) {
-            setSelectionIdx(Math.min(availableShells.length - 1, selectionIdx + 1));
-        }
-        else if (key.return) {
-            await bind(availableShells[selectionIdx]);
-            uiResult = availableShells[selectionIdx];
-            exit();
-        }
-    });
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, null,
-            React.createElement(Text, { bold: true }, "Select your desired shell for keybinding creation")),
-        React.createElement(Box, { flexDirection: "column" },
-            availableShells.map((shell, idx) => {
-                if (idx == selectionIdx) {
-                    return (React.createElement(Text, { color: "cyan", underline: true, key: idx },
-                        ">",
-                        " ",
-                        shell));
-                }
-                return (React.createElement(Text, { key: idx },
-                    "  ",
-                    shell));
-            }),
-            loaded
-                ? supportedShells
-                    .filter((s) => !availableShells.includes(s))
-                    .map((shell, idx) => (React.createElement(Text, { color: "gray", key: idx },
-                    "  ",
-                    shell,
-                    " (already bound)")))
-                : null,
-            !loaded ? React.createElement(Text, null, "Loading...") : null)));
-}
-export const render = async () => {
-    const { waitUntilExit } = inkRender(React.createElement(UI, null));
-    await waitUntilExit();
-    if (uiResult.length !== 0) {
-        process.stdout.write("\n" + chalk.green("✓") + " successfully created new bindings \n");
-    }
-    else {
-        process.stdout.write("\n");
-    }
-};