@hyperweb/telescope 1.15.0

package/main/imports.js

@@ -0,0 +1,416 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDepsFromQueries = exports.getDepsFromMutations = exports.getImportsFromQueries = exports.getImportsFromMutations = exports.aggregateImports = exports.buildAllImportsFromGenericContext = exports.buildAllImports = exports.getImportStatements = void 0;
+const t = __importStar(require("@babel/types"));
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("./utils");
+const utils_2 = require("@cosmology/utils");
+const importHashToArray = (hash) => {
+    return Object.entries(hash ?? {}).reduce((m, [path, names]) => {
+        names.forEach((name) => {
+            m.push({
+                type: "import",
+                name,
+                path,
+            });
+        });
+        return m;
+    }, []);
+};
+const getProtoImports = (context, filename) => {
+    return context.proto.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getAminoImports = (context, filename) => {
+    return context.amino.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getGenericImports = (context, filename) => {
+    return context.generic.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getParsedImports = (context, parsedImports, filename) => {
+    const imports = [];
+    Object.entries(parsedImports ?? {}).forEach(([path, names]) => {
+        if (filename === path)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(filename, path);
+        const aliases = context.ref?.traversed?.importNames?.[path];
+        names.forEach((name) => {
+            let importAs = name;
+            if (aliases && aliases[name]) {
+                importAs = aliases[name];
+            }
+            imports.push({
+                type: "import",
+                name,
+                importAs,
+                path: importPath,
+                protoPath: path,
+            });
+        });
+    });
+    return imports;
+};
+const importAs = (name, importAs, importPath) => {
+    return t.importDeclaration([t.importSpecifier(t.identifier(importAs), t.identifier(name))], t.stringLiteral(importPath));
+};
+// __helpers__
+const getImportStatements = (filepath, list, options) => {
+    const imports = list.reduce((m, obj) => {
+        let editedPath = utils_1.UTIL_HELPERS.includes(obj.path)
+            ? (0, utils_1.getRelativePath)(filepath, `./${obj.path.replace(/__/g, "")}`)
+            : obj.path;
+        editedPath = (0, utils_2.restoreExtension)(editedPath, options?.restoreImportExtension);
+        const clonedObj = { ...obj, path: editedPath };
+        m[clonedObj.path] = m[clonedObj.path] || [];
+        const exists = m[clonedObj.path].find((el) => el.type === clonedObj.type &&
+            el.path === clonedObj.path &&
+            el.name === clonedObj.name);
+        // MARKED AS NOT DRY [google.protobuf names]
+        // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+        if (/\./.test(clonedObj.name)) {
+            clonedObj.name =
+                clonedObj.name.split(".")[clonedObj.name.split(".").length - 1];
+        }
+        if (!exists) {
+            m[clonedObj.path].push(clonedObj);
+        }
+        return m;
+    }, {});
+    return Object.entries(imports).reduce((m, [importPath, imports]) => {
+        const defaultImports = imports.filter((a) => a.type === "default");
+        if (defaultImports.length) {
+            if (defaultImports.length > 1)
+                throw new Error("more than one default name NOT allowed.");
+            m.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(defaultImports[0].name))], t.stringLiteral(defaultImports[0].path)));
+        }
+        const namedImports = imports.filter((a) => a.type === "import" && (!a.importAs || a.name === a.importAs));
+        if (namedImports.length) {
+            m.push((0, ast_1.importStmt)(namedImports.map((i) => i.name), namedImports[0].path));
+        }
+        const aliasNamedImports = imports.filter((a) => a.type === "import" && a.importAs && a.name !== a.importAs);
+        aliasNamedImports.forEach((imp) => {
+            m.push(importAs(imp.name, imp.importAs, imp.path));
+        });
+        const namespaced = imports.filter((a) => a.type === "namespace");
+        if (namespaced.length) {
+            if (namespaced.length > 1)
+                throw new Error("more than one namespaced name NOT allowed.");
+            m.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(namespaced[0].name))], t.stringLiteral(namespaced[0].path)));
+        }
+        return m;
+    }, []);
+};
+exports.getImportStatements = getImportStatements;
+const convertUtilsToImports = (context) => {
+    const list = [];
+    const utils = Object.keys({
+        ...context.amino.utils,
+        ...context.proto.utils,
+        ...context.generic.utils,
+    });
+    utils.forEach((util) => {
+        if (!utils_1.UTILS.hasOwnProperty(util))
+            throw new Error("missing Util! ::" + util);
+        if (typeof utils_1.UTILS[util] === "string") {
+            list.push({
+                type: "import",
+                path: utils_1.UTILS[util],
+                name: util,
+            });
+        }
+        else {
+            list.push(utils_1.UTILS[util]);
+        }
+    });
+    return list;
+};
+const convertUtilsToImportsGenric = (context) => {
+    const list = [];
+    const utils = Object.keys({
+        ...context.utils,
+    });
+    // MARKED AS NOT DRY - duplicate of above
+    utils.forEach((util) => {
+        if (!utils_1.UTILS.hasOwnProperty(util))
+            throw new Error("missing Util! ::" + util);
+        if (typeof utils_1.UTILS[util] === "string") {
+            list.push({
+                type: "import",
+                path: utils_1.UTILS[util],
+                name: util,
+            });
+        }
+        else {
+            list.push(utils_1.UTILS[util]);
+        }
+    });
+    return list;
+};
+const buildAllImports = (context, allImports, filepath) => {
+    const imports = (0, exports.aggregateImports)(context, allImports, filepath);
+    const importStmts = (0, exports.getImportStatements)(filepath, imports, {
+        restoreImportExtension: context.options.restoreImportExtension,
+    });
+    return importStmts;
+};
+exports.buildAllImports = buildAllImports;
+const buildAllImportsFromGenericContext = (context, filepath) => {
+    const imports = convertUtilsToImportsGenric(context);
+    const importStmts = (0, exports.getImportStatements)(filepath, imports, {
+        restoreImportExtension: context.options.restoreImportExtension,
+    });
+    return importStmts;
+};
+exports.buildAllImportsFromGenericContext = buildAllImportsFromGenericContext;
+const addDerivativeTypesToImports = (context, imports) => {
+    const ref = context.ref;
+    return imports.reduce((m, obj) => {
+        // SDKType
+        // probably wont need this until we start generating osmonauts/helpers inline
+        if (obj.type === "import" && obj.path.startsWith(".")) {
+            let lookup = null;
+            try {
+                lookup = context.store.getImportFromRef(ref, obj.name);
+            }
+            catch (e) { }
+            const appendSuffix = (obj, baseType) => {
+                return {
+                    ...obj,
+                    orig: obj.name,
+                    name: ast_1.SymbolNames[baseType](obj.name),
+                    importAs: ast_1.SymbolNames[baseType](obj.importAs ?? obj.name),
+                    protoPath: obj.protoPath,
+                };
+            };
+            // MARKED AS NOT DRY [google.protobuf names]
+            // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+            const removeProtoPrefix = (obj) => {
+                if (/\./.test(obj.name)) {
+                    obj.name = obj.name.split(".")[obj.name.split(".").length - 1];
+                    obj.importAs =
+                        obj.importAs.split(".")[obj.importAs.split(".").length - 1];
+                }
+                return obj;
+            };
+            const SDKTypeObject = removeProtoPrefix(appendSuffix(obj, "SDKType"));
+            const AminoTypeObject = removeProtoPrefix(appendSuffix(obj, "Amino"));
+            const EncodedTypeObject = removeProtoPrefix(appendSuffix(obj, "ProtoMsg"));
+            // const AminoTypeUrlObject = removeProtoPrefix(appendSuffix(obj, 'AminoType'));
+            if (lookup && ["Type", "Enum"].includes(lookup.obj.type)) {
+                const arr = [...m, obj];
+                if (context.options.aminoEncoding?.enabled &&
+                    !context.options.aminoEncoding.useLegacyInlineEncoding) {
+                    // check and see if this derived import has been required...
+                    const foundEnc = context.proto.derivedImports.find((a) => {
+                        if (a.type !== "ProtoMsg")
+                            return false;
+                        if (EncodedTypeObject.orig === a.symbol.symbolName) {
+                            // UNTIL you fix the ImportObjs to have ref...
+                            let rel = (0, utils_1.getRelativePath)(a.symbol.ref, a.symbol.source);
+                            if (rel === EncodedTypeObject.path) {
+                                return true;
+                            }
+                        }
+                    });
+                    const foundAmino = context.proto.derivedImports.find((a) => {
+                        if (a.type !== "Amino")
+                            return false;
+                        if (AminoTypeObject.orig === a.symbol.symbolName &&
+                            a.symbol.ref &&
+                            a.symbol.source) {
+                            // UNTIL you fix the ImportObjs to have ref...
+                            let rel = (0, utils_1.getRelativePath)(a.symbol.ref, a.symbol.source);
+                            if (rel === AminoTypeObject.path) {
+                                return true;
+                            }
+                        }
+                    });
+                    // we need Any types as defaults...
+                    if (foundEnc || EncodedTypeObject.orig === "Any") {
+                        arr.push(EncodedTypeObject);
+                    }
+                    if (foundAmino || AminoTypeObject.orig === "Any") {
+                        arr.push(AminoTypeObject);
+                    }
+                }
+                if (context.options.useSDKTypes) {
+                    // issue in output1 (probably legacy v1 amino transpiler)
+                    // ProposalSDKType wasn't being found in QueryProposalResponseSDKType
+                    arr.push(SDKTypeObject);
+                    // const foundSDK = context.proto.derivedImports.find(a => {
+                    //     if (a.type !== 'SDKType') return false;
+                    //     if (SDKTypeObject.orig === a.symbol.symbolName) {
+                    //         // UNTIL you fix the ImportObjs to have ref...
+                    //         let rel = getRelativePath(a.symbol.ref, a.symbol.source);
+                    //         if (rel === SDKTypeObject.path) {
+                    //             return true;
+                    //         }
+                    //     }
+                    // });
+                    // if (foundSDK) {
+                    //     arr.push(SDKTypeObject);
+                    // }
+                }
+                return arr;
+            }
+        }
+        return [...m, obj];
+    }, []);
+};
+const aggregateImports = (context, allImports, filepath) => {
+    const protoImports = getProtoImports(context, filepath);
+    const aminoImports = getAminoImports(context, filepath);
+    const genericImports = getGenericImports(context, filepath);
+    const parsedImports = getParsedImports(context, context.amino.ref.traversed.parsedImports, filepath);
+    const additionalImports = importHashToArray(allImports);
+    const utilities = convertUtilsToImports(context);
+    let list = []
+        .concat(parsedImports)
+        .concat(utilities)
+        .concat(protoImports)
+        .concat(aminoImports)
+        .concat(genericImports)
+        .concat(additionalImports);
+    if (context.options.useSDKTypes ||
+        (context.options.aminoEncoding?.enabled &&
+            !context.options.aminoEncoding?.useLegacyInlineEncoding)) {
+        list = addDerivativeTypesToImports(context, list);
+    }
+    list = list.filter((imp) => {
+        const alias = context.store.getTypeAlias(imp.orig || imp.name, imp.protoPath);
+        return !alias;
+    });
+    return list;
+};
+exports.aggregateImports = aggregateImports;
+const getImportsFromMutations = (mutations) => {
+    return mutations.map((mutation) => {
+        return {
+            import: mutation.messageImport,
+            name: mutation.message,
+        };
+    });
+};
+exports.getImportsFromMutations = getImportsFromMutations;
+// TODO implement ServiceQuery type (it is the same)
+const getImportsFromQueries = (queries) => {
+    return queries.reduce((m, query) => {
+        const req = {
+            import: query.messageImport,
+            name: query.message,
+        };
+        const res = {
+            import: query.responseImport,
+            name: query.response,
+        };
+        return [...m, req, res];
+    }, []);
+};
+exports.getImportsFromQueries = getImportsFromQueries;
+const getDepsFromMutations = (mutations, filename) => {
+    return (0, exports.getImportsFromMutations)(mutations)
+        .map((imp) => {
+        const f = filename;
+        const f2 = imp.import;
+        if (f === f2)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        return {
+            ...imp,
+            importPath,
+        };
+    })
+        .filter(Boolean)
+        .reduce((m, v) => {
+        m[v.importPath] = m[v.importPath] ?? [];
+        if (!m[v.importPath].includes(v.name)) {
+            m[v.importPath].push(v.name);
+        }
+        return m;
+    }, {});
+};
+exports.getDepsFromMutations = getDepsFromMutations;
+const getDepsFromQueries = (queries, filename) => {
+    return (0, exports.getImportsFromQueries)(queries)
+        .map((imp) => {
+        const f = filename;
+        const f2 = imp.import;
+        if (f === f2)
+            return;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        return {
+            ...imp,
+            importPath,
+        };
+    })
+        .filter(Boolean)
+        .reduce((m, v) => {
+        m[v.importPath] = m[v.importPath] ?? [];
+        if (!m[v.importPath].includes(v.name)) {
+            m[v.importPath].push(v.name);
+        }
+        return m;
+    }, {});
+};
+exports.getDepsFromQueries = getDepsFromQueries;

package/main/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const builder_1 = require("./builder");
+__exportStar(require("./builder"), exports);
+__exportStar(require("./bundler"), exports);
+__exportStar(require("./types"), exports);
+exports.default = async (input) => {
+    const builder = new builder_1.TelescopeBuilder(input);
+    await builder.build();
+};

package/main/parse.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRecur = exports.parseService = exports.parseEnum = exports.parseType = exports.getParsedObjectName = exports.parse = void 0;
+const types_1 = require("@cosmology/types");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("./utils");
+const parse = (context) => {
+    const root = (0, utils_1.getRoot)(context.ref);
+    (0, exports.parseRecur)({
+        context,
+        obj: root.root,
+        scope: [],
+        isNested: false
+    });
+};
+exports.parse = parse;
+const getParsedObjectName = (ref, obj, scope) => {
+    const _scope = [...scope];
+    const root = (0, utils_1.getRoot)(ref);
+    const allButPackage = _scope.splice(root.package.split('.').length);
+    // pull off "this" name
+    allButPackage.pop();
+    return (0, proto_parser_1.getObjectName)(obj.name, [root.package, ...allButPackage]);
+};
+exports.getParsedObjectName = getParsedObjectName;
+// TODO potentially move this back to ast or proto bc the ast lib references MapEntries...
+// Creating those BindingsEntry interfaces
+const makeKeyTypeObj = (ref, field, scope) => {
+    const root = (0, utils_1.getRoot)(ref);
+    const scoped = [...scope].splice(root.package.split('.').length);
+    const adhocObj = {
+        type: 'Type',
+        comment: undefined,
+        fields: {
+            key: {
+                id: 1,
+                type: field.keyType,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.keyType,
+                    type: field.keyType
+                },
+                comment: undefined,
+                options: {
+                    "(telescope:map_entry_type_field)": true
+                }
+            },
+            value: {
+                id: 2,
+                type: field.type,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.parsedType.name,
+                    type: field.parsedType.type
+                },
+                comment: undefined,
+                options: {
+                    "(telescope:map_entry_type_field)": true
+                }
+            }
+        }
+    };
+    return adhocObj;
+};
+const parseType = (context, obj, 
+// scope already has the name of "this" field at the end of it
+scope, isNested = false) => {
+    obj.keyTypes.forEach(field => {
+        const keyTypeObject = makeKeyTypeObj(context.ref, field, [...scope]);
+        const name = (0, exports.getParsedObjectName)(context.ref, {
+            name: (0, ast_1.getKeyTypeEntryName)(obj.name, field.name)
+        }, [...scope]);
+        context.addType(name, keyTypeObject, true);
+    });
+    // parse nested names
+    let name = obj.name;
+    if (isNested) {
+        name = (0, exports.getParsedObjectName)(context.ref, obj, [...scope]);
+    }
+    context.addType(name, obj, isNested);
+    // render nested LAST
+    if (obj.nested) {
+        Object.keys(obj.nested).forEach(key => {
+            // isNested = true;
+            (0, exports.parseRecur)({
+                context,
+                obj: obj.nested[key],
+                scope: [...scope, key],
+                isNested: true
+            });
+        });
+    }
+};
+exports.parseType = parseType;
+const parseEnum = (context, obj, scope, isNested = false) => {
+    let name = obj.name;
+    let enumObj = {
+        ...obj,
+        package: context.ref.proto.package
+    };
+    // parse nested names
+    if (isNested) {
+        name = (0, exports.getParsedObjectName)(context.ref, enumObj, scope);
+    }
+    context.addType(name, enumObj, isNested);
+};
+exports.parseEnum = parseEnum;
+const parseService = (context, obj, scope, isNested = false) => {
+    const methodHash = obj.methods;
+    if (!types_1.ALLOWED_RPC_SERVICES.includes(obj.name)) {
+        return;
+    }
+    Object.entries(methodHash)
+        .forEach(([key, value]) => {
+        const lookup = context.store.get(context.ref, value.requestType);
+        if (!lookup) {
+            console.warn(`cannot find ${value.requestType}`);
+            throw new Error('undefined symbol for service.');
+        }
+        const lookupResponse = context.store.get(context.ref, value.responseType);
+        if (!lookupResponse) {
+            console.warn(`cannot find ${value.responseType}`);
+            throw new Error('undefined symbol for service.');
+        }
+        const serviceInfo = {
+            methodName: key,
+            package: context.ref.proto.package,
+            message: lookup.importedName,
+            messageImport: lookup.import ?? context.ref.filename,
+            response: lookupResponse.importedName,
+            responseImport: lookupResponse.import ?? context.ref.filename,
+            comment: value.comment
+        };
+        switch (obj.name) {
+            case 'Msg':
+                context.addMutation(serviceInfo);
+                break;
+            case 'Query':
+                context.addQuery(serviceInfo);
+                break;
+            default:
+                context.addService(serviceInfo);
+                break;
+        }
+    });
+};
+exports.parseService = parseService;
+const parseRecur = ({ context, obj, scope, isNested }) => {
+    switch (obj.type) {
+        case 'Type':
+            return (0, exports.parseType)(context, obj, scope, isNested);
+        case 'Enum':
+            return (0, exports.parseEnum)(context, obj, scope, isNested);
+        case 'Service':
+            return (0, exports.parseService)(context, obj, scope, isNested);
+        case 'Field':
+            console.log(obj);
+            return;
+        case 'Root':
+        case 'Namespace':
+            if (obj.nested) {
+                return Object.keys(obj.nested).forEach(key => {
+                    (0, exports.parseRecur)({
+                        context,
+                        obj: obj.nested[key],
+                        scope: [...scope, key],
+                        isNested
+                    });
+                });
+            }
+            else {
+                throw new Error('parseRecur() cannot find protobufjs Type');
+            }
+        default:
+        // if (obj.type === 'string') return;
+        // if (obj.type === 'bool') return;
+        // if (obj.type === 'HttpRule') return;
+        // if (obj.type === 'InterfaceDescriptor') return;
+        // if (obj.type === 'ScalarDescriptor') return;
+        // if (obj.type === 'ModuleDescriptor') return;
+        // if (obj.type === 'TableDescriptor') return;
+        // if (obj.type === 'SingletonDescriptor') return;
+        // if (obj.type === 'ModuleSchemaDescriptor') return;
+        // if (obj.type === 'google.api.FieldBehavior') return;
+        // if (obj.type === 'google.api.ResourceReference') return;
+        // if (obj.type === 'google.api.ResourceDescriptor') return;
+        // if (obj.type === 'google.api.RoutingRule') return;
+        // if (obj.type === 'google.api.VisibilityRule') return;
+        // if (obj.type === 'google.longrunning.OperationInfo') return;
+        // throw new Error('parseRecur() cannot find protobufjs Type')
+    }
+};
+exports.parseRecur = parseRecur;

package/main/prompt.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = exports.getFuzzySearchNames = exports.getFuzzySearch = void 0;
+const fuzzy_1 = require("fuzzy");
+const inquirerer_1 = require("inquirerer");
+const getFuzzySearch = (list) => {
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = (0, fuzzy_1.filter)(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return el.original;
+                }));
+            }, 25);
+        });
+    };
+};
+exports.getFuzzySearch = getFuzzySearch;
+const getFuzzySearchNames = (nameValueItemList) => {
+    const list = nameValueItemList.map(({ name, value }) => name);
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = (0, fuzzy_1.filter)(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return nameValueItemList.find(({ name, value }) => el.original == name);
+                }));
+            }, 25);
+        });
+    };
+};
+exports.getFuzzySearchNames = getFuzzySearchNames;
+const transform = (questions) => {
+    return questions.map((q) => {
+        if (q.type === 'fuzzy') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: (0, exports.getFuzzySearch)(choices)
+            };
+        }
+        else if (q.type === 'fuzzy:objects') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: (0, exports.getFuzzySearchNames)(choices)
+            };
+        }
+        else {
+            return q;
+        }
+    });
+};
+const prompt = async (questions = [], argv = {}) => {
+    questions = transform(questions);
+    return await (0, inquirerer_1.prompt)(questions, argv);
+};
+exports.prompt = prompt;