@jalasem/dss/build/utils/fuzzySearch.js

Dev Spaces Switcher (DSS) - Seamlessly manage isolated development environments with separate SSH keys and Git configurations. Enhanced UI with beautiful tables and improved documentation.

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AutocompleteHelper = exports.FuzzySpaceSearch = void 0;
const fuzzy_search_1 = __importDefault(require("fuzzy-search"));
class FuzzySpaceSearch {
    constructor(spaces) {
        this.fuzzySearch = new fuzzy_search_1.default(spaces, ['name', 'email', 'userName'], {
            caseSensitive: false,
            sort: true
        });
    }
    search(query) {
        if (!query.trim()) {
            return [];
        }
        return this.fuzzySearch.search(query);
    }
    static highlightMatch(text, query) {
        if (!query.trim()) {
            return text;
        }
        const regex = new RegExp(`(${query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi');
        return text.replace(regex, '\u001b[33m$1\u001b[0m'); // Yellow highlighting
    }
    static getSearchChoices(spaces, query = '', activeSpace) {
        const searcher = new FuzzySpaceSearch(spaces);
        const searchResults = query ? searcher.search(query) : spaces;
        return searchResults.map(space => ({
            name: space.name === activeSpace ? `🔥 ${space.name}` : space.name,
            value: space.name,
            description: `${space.email} (${space.userName})`
        }));
    }
}
exports.FuzzySpaceSearch = FuzzySpaceSearch;
class AutocompleteHelper {
    static searchSpaces(spaces, message, activeSpace) {
        return __awaiter(this, void 0, void 0, function* () {
            const { input } = yield Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
            let filteredSpaces = spaces;
            let query = '';
            while (true) {
                const choices = FuzzySpaceSearch.getSearchChoices(filteredSpaces, query, activeSpace);
                if (choices.length === 0 && query) {
                    console.log('\n❌ No spaces match your search. Try a different query.');
                    query = '';
                    filteredSpaces = spaces;
                    continue;
                }
                const prompt = query
                    ? `${message} (filtered by: "${query}")`
                    : `${message} (type to search)`;
                const answer = yield input({
                    message: prompt,
                    validate: (input) => {
                        if (!input.trim()) {
                            return 'Please enter a space name or search term';
                        }
                        return true;
                    }
                });
                // If input matches exactly, return it
                const exactMatch = spaces.find(s => s.name.toLowerCase() === answer.toLowerCase());
                if (exactMatch) {
                    return exactMatch.name;
                }
                // Otherwise, use as search query
                query = answer;
                const searcher = new FuzzySpaceSearch(spaces);
                filteredSpaces = searcher.search(query);
                // If only one result, return it
                if (filteredSpaces.length === 1) {
                    return filteredSpaces[0].name;
                }
                // If multiple results, show them
                if (filteredSpaces.length > 1) {
                    console.log(`\n🔍 Found ${filteredSpaces.length} matches:`);
                    filteredSpaces.forEach((space, index) => {
                        const isActive = space.name === activeSpace;
                        const displayName = isActive ? `🔥 ${space.name}` : space.name;
                        console.log(`  ${index + 1}. ${displayName} (${space.email})`);
                    });
                    console.log('');
                }
            }
        });
    }
}
exports.AutocompleteHelper = AutocompleteHelper;