api 7.0.0-alpha.0 → 7.0.0-alpha.1

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    install: import("commander").Command;
+};
+export default _default;

package/dist/commands/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var install_1 = __importDefault(require("./install"));
+exports.default = {
+    install: install_1.default,
+};

package/dist/commands/install.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const cmd: Command;
+export default cmd;

package/dist/commands/install.js

@@ -0,0 +1,239 @@
+"use strict";
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var figures_1 = __importDefault(require("figures"));
+var oas_1 = __importDefault(require("oas"));
+var ora_1 = __importDefault(require("ora"));
+var codegen_1 = __importDefault(require("../codegen"));
+var fetcher_1 = __importDefault(require("../fetcher"));
+var prompt_1 = __importDefault(require("../lib/prompt"));
+var logger_1 = __importDefault(require("../logger"));
+var storage_1 = __importDefault(require("../storage"));
+// @todo log logs to `.api/.logs` and have `.logs` ignored
+var cmd = new commander_1.Command();
+cmd
+    .name('install')
+    .description('install an API SDK into your codebase')
+    .argument('<uri>', 'an API to install')
+    .option('-i, --identifier <identifier>', 'API identifier (eg. `@api/petstore`)')
+    .addOption(new commander_1.Option('-l, --lang <language>', 'SDK language').choices([
+    'js',
+    'js-cjs',
+    'js-esm',
+    'ts',
+]))
+    .addOption(new commander_1.Option('-y, --yes', 'Automatically answer "yes" to any prompts printed'))
+    .action(function (uri, options) { return __awaiter(void 0, void 0, void 0, function () {
+    var language, identifier, spinner, storage, oas, generator, sdkSource, err_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!options.lang) return [3 /*break*/, 1];
+                language = options.lang;
+                return [3 /*break*/, 3];
+            case 1: return [4 /*yield*/, (0, prompt_1.default)({
+                    type: 'select',
+                    name: 'value',
+                    message: 'What language would you like to generate an SDK for?',
+                    choices: [
+                        { title: 'TypeScript', value: 'ts' },
+                        { title: 'JavaScript', value: 'js' },
+                    ],
+                    initial: 1,
+                })];
+            case 2:
+                (language = (_a.sent()).value);
+                _a.label = 3;
+            case 3:
+                if (!(language === 'js')) return [3 /*break*/, 5];
+                return [4 /*yield*/, (0, prompt_1.default)({
+                        type: 'select',
+                        name: 'value',
+                        message: 'How are your project imports and exports structured?',
+                        choices: [
+                            { title: 'CommonJS', description: 'require/exports', value: 'cjs' },
+                            { title: 'ECMAScript Modules', description: 'import/export', value: 'esm' },
+                        ],
+                        initial: 0,
+                        format: function (sel) { return (sel === 'cjs' ? 'js-cjs' : 'js-esm'); },
+                    })];
+            case 4:
+                (language = (_a.sent()).value);
+                _a.label = 5;
+            case 5:
+                // @todo let them know that we're going to be creating a `.api/ directory
+                // @todo detect if they have a gitigore and .npmignore and if .api woudl be ignored by that
+                // @todo don't support swagger files without upconverting them
+                if (storage_1.default.isInLockFile({ source: uri })) {
+                    // @todo
+                    // logger(`It looks like you already have this API installed. Would you like to update it?`);
+                }
+                if (!options.identifier) return [3 /*break*/, 6];
+                // `Storage.isIdentifierValid` will throw an exception if an identifier is invalid.
+                if (storage_1.default.isIdentifierValid(options.identifier)) {
+                    identifier = options.identifier;
+                }
+                return [3 /*break*/, 9];
+            case 6:
+                if (!fetcher_1.default.isAPIRegistryUUID(uri)) return [3 /*break*/, 7];
+                identifier = fetcher_1.default.getProjectPrefixFromRegistryUUID(uri);
+                return [3 /*break*/, 9];
+            case 7: return [4 /*yield*/, (0, prompt_1.default)({
+                    type: 'text',
+                    name: 'value',
+                    message: 'What would you like to identify this API as? This will be how you import the SDK. (e.g. entering `petstore` would result in `@api/petstore`)',
+                    validate: function (value) {
+                        if (!value) {
+                            return false;
+                        }
+                        try {
+                            return storage_1.default.isIdentifierValid(value, true);
+                        }
+                        catch (err) {
+                            return err.message;
+                        }
+                    },
+                })];
+            case 8:
+                (identifier = (_a.sent()).value);
+                _a.label = 9;
+            case 9:
+                if (!identifier) {
+                    (0, logger_1.default)('You must tell us what you would like to identify this API as in order to install it.', true);
+                    process.exit(1);
+                }
+                spinner = (0, ora_1.default)('Fetching your API').start();
+                storage = new storage_1.default(uri, identifier);
+                return [4 /*yield*/, storage
+                        .load()
+                        .then(function (res) {
+                        spinner.succeed(spinner.text);
+                        return res;
+                    })
+                        .then(oas_1.default.init)
+                        .catch(function (err) {
+                        // @todo cleanup installed files
+                        spinner.fail(spinner.text);
+                        (0, logger_1.default)(err.message, true);
+                        process.exit(1);
+                    })];
+            case 10:
+                oas = _a.sent();
+                // @todo look for a prettier config and if we find one ask them if we should use it
+                spinner = (0, ora_1.default)('Generating your SDK').start();
+                generator = (0, codegen_1.default)(language, oas, './openapi.json', identifier);
+                return [4 /*yield*/, generator
+                        .generator()
+                        .then(function (res) {
+                        spinner.succeed(spinner.text);
+                        return res;
+                    })
+                        .catch(function (err) {
+                        // @todo cleanup installed files
+                        spinner.fail(spinner.text);
+                        (0, logger_1.default)(err.message, true);
+                        process.exit(1);
+                    })];
+            case 11:
+                sdkSource = _a.sent();
+                spinner = (0, ora_1.default)('Saving your SDK into your codebase').start();
+                return [4 /*yield*/, storage
+                        .saveSourceFiles(sdkSource)
+                        .then(function () {
+                        spinner.succeed(spinner.text);
+                    })
+                        .catch(function (err) {
+                        // @todo cleanup installed files
+                        spinner.fail(spinner.text);
+                        (0, logger_1.default)(err.message, true);
+                        process.exit(1);
+                    })];
+            case 12:
+                _a.sent();
+                if (!generator.hasRequiredPackages()) return [3 /*break*/, 18];
+                (0, logger_1.default)("".concat(figures_1.default.warning, " This generator requires some packages to be installed alongside it:"));
+                Object.entries(generator.requiredPackages).forEach(function (_a) {
+                    var pkg = _a[0], pkgInfo = _a[1];
+                    (0, logger_1.default)("  ".concat(figures_1.default.pointerSmall, " ").concat(pkg, ": ").concat(pkgInfo.reason, " ").concat(pkgInfo.url));
+                });
+                if (!!options.yes) return [3 /*break*/, 14];
+                return [4 /*yield*/, (0, prompt_1.default)({
+                        type: 'confirm',
+                        name: 'value',
+                        message: 'OK to proceed with package installation?',
+                        initial: true,
+                    }).then(function (_a) {
+                        var value = _a.value;
+                        if (!value) {
+                            // @todo cleanup installed files
+                            (0, logger_1.default)('Installation cancelled.', true);
+                            process.exit(1);
+                        }
+                    })];
+            case 13:
+                _a.sent();
+                _a.label = 14;
+            case 14:
+                spinner = (0, ora_1.default)('Installing required packages').start();
+                _a.label = 15;
+            case 15:
+                _a.trys.push([15, 17, , 18]);
+                return [4 /*yield*/, generator.installer(storage)];
+            case 16:
+                _a.sent();
+                spinner.succeed(spinner.text);
+                return [3 /*break*/, 18];
+            case 17:
+                err_1 = _a.sent();
+                // @todo cleanup installed files
+                spinner.fail(spinner.text);
+                (0, logger_1.default)(err_1.message, true);
+                process.exit(1);
+                return [3 /*break*/, 18];
+            case 18:
+                (0, logger_1.default)('🚀 All done!');
+                return [2 /*return*/];
+        }
+    });
+}); })
+    .addHelpText('after', "\nExamples:\n  $ api install @developers/v2.0#nysezql0wwo236\n  $ api install https://raw.githubusercontent.com/readmeio/oas-examples/main/3.0/json/petstore-simple.json\n  $ api install ./petstore.json");
+exports.default = cmd;

package/dist/fetcher.d.ts

@@ -0,0 +1,53 @@
+import type { OASDocument } from 'oas/dist/rmoas.types';
+export default class Fetcher {
+    uri: string | OASDocument;
+    /**
+     * @example @petstore/v1.0#n6kvf10vakpemvplx
+     * @example @petstore#n6kvf10vakpemvplx
+     */
+    static registryUUIDRegex: RegExp;
+    constructor(uri: string | OASDocument);
+    static isAPIRegistryUUID(uri: string): boolean;
+    static isGitHubBlobURL(uri: string): boolean;
+    static getProjectPrefixFromRegistryUUID(uri: string): string | undefined;
+    load(): Promise<(Omit<Omit<import("openapi-types").OpenAPIV3.Document<{}>, "paths" | "components">, "paths" | "components" | "info" | "servers" | "webhooks" | "jsonSchemaDialect"> & {
+        info: import("openapi-types").OpenAPIV3_1.InfoObject;
+        jsonSchemaDialect?: string | undefined;
+        servers?: import("openapi-types").OpenAPIV3_1.ServerObject[] | undefined;
+    } & Pick<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }, "paths"> & Omit<Partial<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }>, "paths"> & Record<string, unknown>) | (Omit<Omit<import("openapi-types").OpenAPIV3.Document<{}>, "paths" | "components">, "paths" | "components" | "info" | "servers" | "webhooks" | "jsonSchemaDialect"> & {
+        info: import("openapi-types").OpenAPIV3_1.InfoObject;
+        jsonSchemaDialect?: string | undefined;
+        servers?: import("openapi-types").OpenAPIV3_1.ServerObject[] | undefined;
+    } & Pick<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }, "webhooks"> & Omit<Partial<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }>, "webhooks"> & Record<string, unknown>) | (Omit<Omit<import("openapi-types").OpenAPIV3.Document<{}>, "paths" | "components">, "paths" | "components" | "info" | "servers" | "webhooks" | "jsonSchemaDialect"> & {
+        info: import("openapi-types").OpenAPIV3_1.InfoObject;
+        jsonSchemaDialect?: string | undefined;
+        servers?: import("openapi-types").OpenAPIV3_1.ServerObject[] | undefined;
+    } & Pick<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }, "components"> & Omit<Partial<{
+        paths: import("openapi-types").OpenAPIV3_1.PathsObject<{}, {}>;
+        webhooks: Record<string, import("openapi-types").OpenAPIV3_1.ReferenceObject | import("openapi-types").OpenAPIV3_1.PathItemObject<{}>>;
+        components: import("openapi-types").OpenAPIV3_1.ComponentsObject;
+    }>, "components"> & Record<string, unknown>) | (import("openapi-types").OpenAPIV3.Document<{}> & Record<string, unknown>)>;
+    static getURL(url: string): Promise<any>;
+    static getFile(uri: string): Promise<any>;
+    static validate(json: OASDocument): Promise<import("openapi-types").OpenAPI.Document<{}>>;
+}

package/dist/fetcher.js

@@ -0,0 +1,164 @@
+"use strict";
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_fs_1 = __importDefault(require("node:fs"));
+var node_path_1 = __importDefault(require("node:path"));
+var openapi_parser_1 = __importDefault(require("@readme/openapi-parser"));
+var js_yaml_1 = __importDefault(require("js-yaml"));
+var Fetcher = /** @class */ (function () {
+    function Fetcher(uri) {
+        if (typeof uri === 'string') {
+            if (Fetcher.isAPIRegistryUUID(uri)) {
+                // Resolve OpenAPI definition shorthand accessors from within the ReadMe API Registry.
+                this.uri = uri.replace(Fetcher.registryUUIDRegex, 'https://dash.readme.com/api/v1/api-registry/$4');
+            }
+            else if (Fetcher.isGitHubBlobURL(uri)) {
+                /**
+                 * People may try to use a public repository URL to the source viewer on GitHub not knowing
+                 * that this page actually serves HTML. In this case we want to rewrite these to the "raw"
+                 * version of this page that'll allow us to access the API definition.
+                 *
+                 * @example https://github.com/readmeio/oas-examples/blob/main/3.1/json/petstore.json
+                 */
+                this.uri = uri.replace(/\/\/github.com/, '//raw.githubusercontent.com').replace(/\/blob\//, '/');
+            }
+            else {
+                this.uri = uri;
+            }
+        }
+        else {
+            this.uri = uri;
+        }
+    }
+    Fetcher.isAPIRegistryUUID = function (uri) {
+        return Fetcher.registryUUIDRegex.test(uri);
+    };
+    Fetcher.isGitHubBlobURL = function (uri) {
+        return /\/\/github.com\/[-_a-zA-Z0-9]+\/[-_a-zA-Z0-9]+\/blob\/(.*).(yaml|json|yml)/.test(uri);
+    };
+    Fetcher.getProjectPrefixFromRegistryUUID = function (uri) {
+        var _a;
+        var matches = uri.match(Fetcher.registryUUIDRegex);
+        if (!matches) {
+            return undefined;
+        }
+        return (_a = matches.groups) === null || _a === void 0 ? void 0 : _a.project;
+    };
+    Fetcher.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (typeof this.uri !== 'string') {
+                    throw new TypeError("Something disastrous occurred and a non-string URI was supplied to the Fetcher library. This shouldn't have happened!");
+                }
+                return [2 /*return*/, Promise.resolve(this.uri)
+                        .then(function (uri) {
+                        var url;
+                        try {
+                            url = new URL(uri);
+                        }
+                        catch (err) {
+                            // If that try fails for whatever reason than the URI that we have isn't a real URL and
+                            // we can safely attempt to look for it on the filesystem.
+                            return Fetcher.getFile(uri);
+                        }
+                        return Fetcher.getURL(url.href);
+                    })
+                        .then(function (res) { return Fetcher.validate(res); })
+                        .then(function (res) { return res; })];
+            });
+        });
+    };
+    Fetcher.getURL = function (url) {
+        // @todo maybe include our user-agent here to identify our request
+        return fetch(url).then(function (res) {
+            if (!res.ok) {
+                throw new Error("Unable to retrieve URL (".concat(url, "). Reason: ").concat(res.statusText));
+            }
+            if (res.headers.get('content-type') === 'application/yaml' || /\.(yaml|yml)/.test(url)) {
+                return res.text().then(function (text) {
+                    return js_yaml_1.default.load(text);
+                });
+            }
+            return res.json();
+        });
+    };
+    Fetcher.getFile = function (uri) {
+        // Support relative paths by resolving them against the cwd.
+        var file = node_path_1.default.resolve(process.cwd(), uri);
+        if (!node_fs_1.default.existsSync(file)) {
+            throw new Error("Sorry, we were unable to load an API definition from ".concat(file, ". Please either supply a URL or a path on your filesystem."));
+        }
+        return Promise.resolve(node_fs_1.default.readFileSync(file, 'utf8')).then(function (res) {
+            if (/\.(yaml|yml)/.test(file)) {
+                return js_yaml_1.default.load(res);
+            }
+            return JSON.parse(res);
+        });
+    };
+    Fetcher.validate = function (json) {
+        if (json.swagger) {
+            throw new Error('Sorry, this module only supports OpenAPI definitions.');
+        }
+        // The `validate` method handles dereferencing for us.
+        return openapi_parser_1.default.validate(json, {
+            dereference: {
+                /**
+                 * If circular `$refs` are ignored they'll remain in the API definition as `$ref: String`.
+                 * This allows us to not only do easy circular reference detection but also stringify and
+                 * save dereferenced API definitions back into the cache directory.
+                 */
+                circular: 'ignore',
+            },
+        }).catch(function (err) {
+            if (/is not a valid openapi definition/i.test(err.message)) {
+                throw new Error("Sorry, that doesn't look like a valid OpenAPI definition.");
+            }
+            throw err;
+        });
+    };
+    /**
+     * @example @petstore/v1.0#n6kvf10vakpemvplx
+     * @example @petstore#n6kvf10vakpemvplx
+     */
+    Fetcher.registryUUIDRegex = /^@(?<project>[a-zA-Z0-9-_]+)(\/?(?<version>.+))?#(?<uuid>[a-z0-9]+)$/;
+    return Fetcher;
+}());
+exports.default = Fetcher;

package/dist/lib/prompt.d.ts

@@ -0,0 +1,9 @@
+import prompts from 'prompts';
+/**
+ * The `prompts` library doesn't always interpret CTRL+C and release the terminal back to the user
+ * so we need handle this ourselves. This function is just a simple overload of the main `prompts`
+ * import that we use.
+ *
+ * @see {@link https://github.com/terkelg/prompts/issues/252}
+ */
+export default function promptTerminal<T extends string = string>(question: prompts.PromptObject<T>, options?: prompts.Options): Promise<prompts.Answers<T>>;

package/dist/lib/prompt.js

@@ -0,0 +1,81 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var prompts_1 = __importDefault(require("prompts"));
+/**
+ * The `prompts` library doesn't always interpret CTRL+C and release the terminal back to the user
+ * so we need handle this ourselves. This function is just a simple overload of the main `prompts`
+ * import that we use.
+ *
+ * @see {@link https://github.com/terkelg/prompts/issues/252}
+ */
+function promptTerminal(question, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var enableTerminalCursor, onState;
+        return __generator(this, function (_a) {
+            enableTerminalCursor = function () {
+                process.stdout.write('\x1B[?25h');
+            };
+            onState = function (state) {
+                if (state.aborted) {
+                    // If we don't re-enable the terminal cursor before exiting the program, the cursor will
+                    // remain hidden.
+                    enableTerminalCursor();
+                    process.stdout.write('\n');
+                    process.exit(1);
+                }
+            };
+            return [2 /*return*/, (0, prompts_1.default)(__assign(__assign({}, question), { onState: onState }), options)];
+        });
+    });
+}
+exports.default = promptTerminal;

package/dist/logger.d.ts

@@ -0,0 +1 @@
+export default function logger(log: string, error?: boolean): void;

package/dist/logger.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+var chalk_1 = __importDefault(require("chalk"));
+function logger(log, error) {
+    if (error) {
+        console.error(chalk_1.default.red(log));
+    }
+    else {
+        console.log(log);
+    }
+}
+exports.default = logger;

package/dist/packageInfo.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_NAME = "api";
+export declare const PACKAGE_VERSION = "7.0.0-alpha.1";

package/dist/packageInfo.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_VERSION = exports.PACKAGE_NAME = void 0;
+// This file is automatically updated by the build script.
+exports.PACKAGE_NAME = 'api';
+exports.PACKAGE_VERSION = '7.0.0-alpha.1';