@wocker/utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kris Papercut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @wocker/utils
+
+###### Docker workspace for web projects
+
+## Usage
+
+### Installation
+
+```shell
+npm i @wocker/utils
+```

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./promptConfirm";
+export * from "./promptGroup";
+export * from "./promptSelect";
+export * from "./promptText";

package/lib/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./promptConfirm"), exports);
+__exportStar(require("./promptGroup"), exports);
+__exportStar(require("./promptSelect"), exports);
+__exportStar(require("./promptText"), exports);

package/lib/promptConfirm.d.ts

@@ -0,0 +1,6 @@
+type Options = {
+    message?: string;
+    default?: boolean;
+};
+export declare const promptConfirm: (options: Options) => Promise<any>;
+export { Options as PromptConfirmOptions };

package/lib/promptConfirm.js

@@ -0,0 +1,27 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptConfirm = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const promptConfirm = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { message, default: defaultValue = true } = options;
+    const { confirm } = yield inquirer_1.default.prompt({
+        type: "confirm",
+        name: "confirm",
+        message,
+        default: defaultValue
+    });
+    return confirm;
+});
+exports.promptConfirm = promptConfirm;

package/lib/promptGroup.d.ts

@@ -0,0 +1,14 @@
+import { PromptConfirmOptions } from "./promptConfirm";
+import { PromptSelectOptions } from "./promptSelect";
+import { PromptTextOptions } from "./promptText";
+type ConfirmOptions = PromptConfirmOptions & {
+    type: "boolean";
+};
+type SelectOptions = PromptSelectOptions & {
+    type: "select";
+};
+type Options = {
+    [key: string]: PromptTextOptions | ConfirmOptions | SelectOptions;
+};
+export declare const promptGroup: (options: Options, values?: any) => Promise<any>;
+export {};

package/lib/promptGroup.js

@@ -0,0 +1,54 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptGroup = void 0;
+const promptConfirm_1 = require("./promptConfirm");
+const promptSelect_1 = require("./promptSelect");
+const promptText_1 = require("./promptText");
+const promptGroup = (options, values = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const res = {};
+    for (const key in options) {
+        const params = options[key];
+        switch (params.type) {
+            case "number":
+            case "int":
+            case "string": {
+                res[key] = yield (0, promptText_1.promptText)(Object.assign(Object.assign({}, params), { default: values[key] || params.default }));
+                break;
+            }
+            case "boolean": {
+                const { type } = params, rest = __rest(params, ["type"]);
+                res[key] = yield (0, promptConfirm_1.promptConfirm)(Object.assign(Object.assign({}, rest), { default: typeof values[key] !== "undefined"
+                        ? values[key] === "true"
+                        : params.default }));
+                break;
+            }
+            case "select": {
+                const { type } = params, rest = __rest(params, ["type"]);
+                res[key] = yield (0, promptSelect_1.promptSelect)(Object.assign(Object.assign({}, rest), { default: values[key] || params.default }));
+                break;
+            }
+        }
+    }
+    return res;
+});
+exports.promptGroup = promptGroup;

package/lib/promptSelect.d.ts

@@ -0,0 +1,12 @@
+type Options = {
+    message?: string;
+    options: string[] | {
+        [value: string]: string;
+    } | {
+        label?: string;
+        value: string;
+    }[];
+    default?: string;
+};
+export declare const promptSelect: (props: Options) => Promise<string>;
+export { Options as PromptSelectOptions };

package/lib/promptSelect.js

@@ -0,0 +1,56 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptSelect = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const promptSelect = (props) => __awaiter(void 0, void 0, void 0, function* () {
+    const { message, options: rawOptions, default: defaultValue } = props;
+    const options = Array.isArray(rawOptions)
+        ? rawOptions.map((option) => {
+            return {
+                label: typeof option === "string"
+                    ? option
+                    : option.label || option.value || "",
+                value: typeof option === "string"
+                    ? option
+                    : option.value || ""
+            };
+        })
+        : Object.keys(rawOptions).map((value) => {
+            return {
+                label: rawOptions[value],
+                value
+            };
+        });
+    const defaultOption = options.find((option) => {
+        return option.value === defaultValue;
+    });
+    const { value } = yield inquirer_1.default.prompt({
+        choices: options.map((option) => {
+            return option.label;
+        }),
+        message,
+        name: "value",
+        type: "list",
+        default: defaultOption ? (defaultOption.label || defaultOption.value) : ""
+    });
+    const selected = options.find((option) => {
+        return option.label === value;
+    });
+    if (selected) {
+        return selected.value;
+    }
+    return "";
+});
+exports.promptSelect = promptSelect;

package/lib/promptText.d.ts

@@ -0,0 +1,10 @@
+type Options = {
+    required?: boolean;
+    message?: string;
+    prefix?: string;
+    suffix?: string;
+    type?: "string" | "number" | "int";
+    default?: number | string;
+};
+export declare const promptText: (options: Options) => Promise<any>;
+export { Options as PromptTextOptions };

package/lib/promptText.js

@@ -0,0 +1,52 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptText = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const promptText = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { required, message, prefix = "", suffix = "", type, default: defaultValue } = options;
+    const { value } = yield inquirer_1.default.prompt({
+        name: "value",
+        type: "input",
+        message,
+        default: defaultValue,
+        validate(value) {
+            if (required) {
+                if (typeof value === "undefined" || value === "") {
+                    return "Mandatory value";
+                }
+            }
+            if (type === "int" || type === "number") {
+                if (isNaN(parseInt(value)) || parseInt(value).toString() !== value) {
+                    return "Should be integer";
+                }
+            }
+            return true;
+        },
+        transformer(value) {
+            if (!prefix && !suffix) {
+                return value;
+            }
+            if (suffix) {
+                setTimeout(() => {
+                    process.stdout.write(`\x1b[${suffix.length}D`);
+                }, 0);
+            }
+            return `${chalk_1.default.gray(prefix)}${value}${chalk_1.default.gray(suffix)}`;
+        }
+    });
+    return value;
+});
+exports.promptText = promptText;

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@wocker/utils",
+    "version": "1.0.0",
+    "author": "Kris Papercut <krispcut@gmail.com>",
+    "description": "Utils for @wocker",
+    "license": "MIT",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "homepage": "https://github.com/kearisp/wocker-utils#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kearisp/wocker-utils.git"
+    },
+    "bugs": {
+        "url": "https://github.com/kearisp/wocker-utils/issues"
+    },
+    "scripts": {
+        "prepare": "npm run build",
+        "watch": "tsc -w",
+        "build": "tsc",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+        "inquirer": "^7.0.0"
+    },
+    "devDependencies": {
+        "jest": "^29.7.0",
+        "typescript": "^5.2.2"
+    }
+}