mixcli 3.2.0 → 3.2.2

package/src/prompt.ts

@@ -1,113 +1,190 @@
+import { isPlainObject } from "flex-tools/typecheck/isPlainObject"
+import { isNumber  } from "flex-tools/typecheck/isNumber"
+
 import { PromptObject } from "prompts" 
 import { outputDebug } from "./utils"
- 
+import { MixOption } from "./option" 
 
-export type PromptType = "text" | "password" | "invisible" | "number"| "confirm"| "list"| "toggle"| "select" | "multiselect" | "autocomplete" | "date" | "autocompleteMultiselect"
+export type PromptType = "text" | "password" | "invisible" | "number"| "confirm"| "list" 
+    | "toggle"| "select" | "multiselect" | "autocomplete" | "date" | "autocompleteMultiselect"
 
 export type PromptParam = 'auto' | boolean | PromptType | PromptObject
 export type InputPromptParam = PromptParam | ((value:any)=>PromptParam) | boolean
 export type PromptParamDefaultValue = string | boolean | string[]  
 
 export const promptTypeMap:Record<string,string> = {
-    boolean:"confirm",
-    string:"text",
-    number:"number",                        
-    array:"list",                        
+    boolean: "confirm",
+    string : "text",
+    number : "number",                        
+    array  : "list",                        
+    date   : "date"
 } 
 
-export const supportedPromptTypes = ["text","password","invisible", "number", "confirm" , "list", "toggle" , "select" , "multiselect" , "autocomplete" , "date" , "autocompleteMultiselect"]
+export const supportedPromptTypes = [
+    "text",
+    "password",
+    "invisible", 
+    "number", 
+    "confirm" , 
+    "list", 
+    "toggle" , 
+    "select" , 
+    "multiselect" , 
+    "autocomplete" , 
+    "date" , 
+    "autocompleteMultiselect"
+]
+
 export interface PromptChoice {
-    title: string;
-    value?: any;
-    disabled?: boolean | undefined;
-    selected?: boolean | undefined;
+    title       : string;
+    value?      : any;
+    disabled?   : boolean | undefined;
+    selected?   : boolean | undefined;
     description?: string | undefined;
 }
 
-
-
-export interface IPromptableOptions{
-    required?: boolean;                         // A value must be supplied when the option is specified.
-    optional?: boolean;                         // A value is optional when the option is specified.
-    default?:PromptParamDefaultValue
-    choices?:(PromptChoice | any)[]                           // 选项值的可选值
-    prompt?:InputPromptParam
-    validate?:(value: any) => boolean
-}
-
-
-export interface IPromptable{
-    name():string 
-    description?:string
-    flags:string
-    promptChoices?:PromptChoice[]
-    argChoices?:string[]
-    variadic?:boolean
-    defaultValue?:PromptParamDefaultValue
-    input?:any        
-    required?:boolean
-    validate?: (value: any) => boolean  
-    getPrompt(inputValue?:any):PromptObject | undefined 
-}
-
-/**
- * 供command.option()使用的参数对象
- */
-export interface PromptableObject{
-   
-
-}
-
+ 
+export type PromptParams = Omit<PromptObject,'name'> | PromptType | boolean | 'auto' | undefined     
 
 /**
  * 负责生成prompt对象
  * 
  */
-export class PromptManager{
-    args:InputPromptParam                           
-    private _promptable:IPromptable                 // 对应的FlexOption或FlexArgument
-    constructor(promptable:IPromptable,promptArgs?:InputPromptParam){ 
-        this._promptable = promptable
-        this.args= promptArgs===undefined ? 'auto' : promptArgs
+export class MixOptionPrompt{
+    params?: PromptParams
+    constructor(public cliOption:MixOption,promptParams?:PromptParams){ 
+        this.params = promptParams
     }
-
     /**
      * 返回输入的是否是有效的prompt类型
      * @param type 
      * @returns 
      */
-    isValid(type:any){
+    isValidPromptType(type:any){
         return  supportedPromptTypes.includes(String(type))
     }
     /**
      * 推断是否需要提示
      * 
+     * 1. 显式指定prompt=true或者提示类型，或者提示对象，则需要提示
+     * 
+     * 
      */
-    isNeed(input:any,defaultValue?:any){
+    isNeedPrompt(input:any,defaultValue?:any){
     
-        const promptArg = this.args
+        const params = this.params
+
         const inputValue = input || defaultValue
+
         // 是否有输入值，即在命令行输入了值
         const hasInput = !(inputValue === undefined)
+        
         // 1. 显式指定了_prompt为true，则需要提示，后续进行提示类型的推断，可能不会准确
-        if(promptArg===true) return true
-        if(promptArg===false) return false        
+        if(params === true) return true
+        if(params === false) return false                
+        if(params === 'auto') return !hasInput
 
         // 2. 提供了一个prompt对象，并且没有在命令行输入值，则需要提示
-        if(typeof(promptArg)=='object'){
+        if(isPlainObject(params)){
             return !hasInput
         }
 
         // 3. 指定了内置的prompt类型，如prompt='password'，则使用password类型提示输入
-        if(typeof(promptArg) == 'string' && supportedPromptTypes.includes(promptArg)){
-            return  !hasInput
+        if(typeof(params) == 'string' && this.isValidPromptType(params)){
+            return  true
         }
+
+        // 4. 指定了可选值，但是没有输入值，则需要提示
+        const isOptional = /(\<s*\w\s*\>)/.test(this.cliOption.flags) 
+        if(isOptional) return !hasInput
         
         // 4. 判断输入是否有效，则显示提示
-        if(this._promptable.argChoices && this._promptable.argChoices.indexOf(inputValue) == -1){
+        if(this.cliOption.argChoices && this.cliOption.argChoices.indexOf(inputValue) == -1){
             return true
         } 
         return !hasInput
+
+    }
+    
+    private _getChoices(){
+        let choices:(string | PromptChoice)[] | ((pre:any,answers:any)=>(string | PromptChoice)[]) = []
+        let choicesParam = this.cliOption.params?.choices
+        if(this.cliOption.argChoices){
+            choices =  this.cliOption.argChoices.map(choice=>{
+                if(typeof(choice)=='string'){
+                    return {title:choice,value:choice}
+                }else{
+                    return choice
+                }
+            })
+        }else if(choicesParam){
+            choices = typeof(choicesParam)=='function' ? choicesParam : [] 
+        }else{
+            return []
+        } 
+        return choices
+    } 
+
+    /**
+     * 自动推断prompt类型
+     * 
+     * 
+     * 
+     * @param inputValue   从命令行输入的值
+     */
+    infer(inputValue?:any){
+
+        const { variadic, defaultValue } = this.cliOption
+
+        const input = inputValue || defaultValue
+
+        // 如果选择指定了"-p [value]或[value...]"，则使用text类型，如果没有要求输入值，则使用confirm类型
+        let promptType:PromptType = 'text'
+
+        const params = this.params
+
+        if(this.isValidPromptType(params)){   // 显式指定了prompt类型,m则以指定的类型为准            
+            promptType = params as PromptType
+        }else if(isPlainObject(params)){     // 显式指定了prompt对象
+            promptType = (params as PromptObject).type as PromptType
+        }else{          // 自动推断prompt类型
+        
+            const isListType = /(\[\s*\w+\.\.\.\s*])|(\<\s*\w+\.\.\.\s*>)/.test(this.cliOption.flags)
+            const isTextType = /(\<s*\w+\s*\>)|(\[\w+\])/.test(this.cliOption.flags) 
+            const isBooleanType = !/(\[\s*\w+s*])|(\<\s*\w+\s*>)/.test(this.cliOption.flags)
+            const isNumberType = isNumber(defaultValue)
+            const isDate = defaultValue && defaultValue instanceof Date
+
+            // 根据默认值的类型推断
+            const datatype:string = Array.isArray(input) ? 'array' : 
+                input instanceof Date ? 'date' :
+                typeof(input)                              
+
+            const optionParams = this.cliOption.params
+
+            if(optionParams && optionParams.choices){
+                const choices = optionParams.choices
+                if(isBooleanType && (Array.isArray(choices) && choices.length==2)){
+                    promptType = 'toggle'
+                }else{
+                    promptType = variadic ? 'multiselect' : 'select'
+                }                
+            }else if(isListType){   // 提供多个可选值时
+                promptType = 'list'
+            }else if(isDate){
+                promptType = 'date'
+            }else if(isNumberType){
+                promptType = 'number'
+            }else if(isTextType){   // 提供一个可选值时
+                promptType = 'text' 
+            }else if(isBooleanType || typeof(defaultValue)==='boolean'){
+                promptType = 'confirm'
+            }else if(datatype in promptTypeMap){
+                promptType = promptTypeMap[datatype] as PromptType
+            }
+        }
+        outputDebug("选项<{}> -> 提示类型<{}>",[this.cliOption.name(),promptType])
+        return promptType
     }
     /**
      * 返回生成prompt对象
@@ -115,66 +192,62 @@ export class PromptManager{
      * @param inputValue   从命令行输入的值
      */
     get(inputValue?:any){
-        const {description,promptChoices,validate,defaultValue} = this._promptable
+
+        const { description, defaultValue } = this.cliOption
+        
         let input = inputValue || defaultValue
-        // 判断是否需要输入提示
-        if(!this.isNeed(input,defaultValue)) return
-        // 推断prompt类型
-        let promptType = this.infer(inputValue)
+
+        // 1. 判断是否需要启用提示
+        if(!this.isNeedPrompt(input,defaultValue)) return
+
+        // 2. 推断prompt类型
+        const promptType = this.infer(inputValue)
+
         const prompt = {
-            type:promptType,                        
-            name:this._promptable.name(),
-            message:description,
+            type   : promptType,                        
+            name   : this.cliOption.attributeName(),
+            message: description,
             initial: input,
-            ...typeof(this.args) == 'object' ? this.args : {}
+            ...typeof(this.params) == 'object' ? this.params : {}
         } as PromptObject
+
+
         // 指定了验证函数，用来验证输入值是否有效
-        prompt.validate = validate?.bind(this._promptable)
+        prompt.validate = this.cliOption.params?.validate
+
         if(promptType=='multiselect') prompt.instructions=false
-        if(['select','multiselect'].includes(promptType)){
-            let index = promptChoices?.findIndex(item=>item.value==input)
-            prompt.initial = index==-1 ? undefined : index
-        } 
-        // 选项值的可选值
-        if(Array.isArray(promptChoices)) {
-            prompt.choices =promptChoices
+        prompt.choices = prompt.choices || this._getChoices()  as any 
+
+        if(['select','multiselect'].includes(promptType)){                  
+
+        }else if(promptType=='toggle'){  
+            if(Array.isArray(prompt.choices)){
+                if(!prompt.active) prompt.active = prompt.choices[0].value
+                if(!prompt.inactive) prompt.inactive = prompt.choices[1].value                
+            }
         }
-        return prompt
-    }
-    /**
-     * 推断prompt类型
-     * 
-     * @param inputValue   从命令行输入的值
-     */
-    infer(inputValue?:any){
-        const {argChoices,variadic,defaultValue} = this._promptable
-        let input = inputValue || defaultValue
-        // 如果选择指定了"-p [value]或[value...]"，则使用text类型，如果没有要求输入值，则使用confirm类型
-        let promptType = /(\<[\w\.]+\>)|(\[[\w\.]+\])/.test(this._promptable.flags) ? 'text' : 'confirm'
-        let promptArg = this.args
-        if(this.isValid(promptArg)){   // 显式指定了prompt类型
-            promptType = promptArg as string
-        }else{          // 未显式指定prompt类型，需要按一定规则推断类型
-            if(typeof(promptArg)=='object'){
-                promptType = promptArg.type as string
-            }else{
-                if(argChoices){  // 提供多个可选值时
-                    promptType = variadic ? 'multiselect' : 'select'
-                }else{
-                    const datatype:string = Array.isArray(defaultValue) ? 'array' : typeof(defaultValue)                              
-                    // 如果输入值班是数组，则使用list类型,允许使用逗号分隔的多个值
-                    if(Array.isArray(input) || variadic){
-                        promptType = "list"
-                    }else{
-                        if(datatype in promptTypeMap){
-                            promptType = promptTypeMap[datatype]
-                        }
+
+        if(input && typeof(prompt.initial)!='function'){
+            if(prompt.choices && Array.isArray(prompt.choices)){
+                if(promptType=='select'){
+                    const index = Array.isArray(prompt.choices) ? prompt.choices.findIndex(item=>item.value==input) : -1
+                    if(index!=-1){
+                        prompt.initial = index
                     }
+                }else if(promptType=='multiselect'){                
+                    prompt.choices.forEach((item)=>{
+                        if(Array.isArray(input) && input.includes(item.value)){
+                            item.selected = true
+                        }else if(item.value==input){
+                            item.selected = true
+                        }
+                    })
                 }
             }
         }
-        outputDebug("选项<{}> -> 提示类型<{}>",[this._promptable.name(),promptType])
-        return promptType
+
+        return prompt
     }
 
+
 }

package/src/utils.ts

@@ -1,158 +1,144 @@
-import artTemplate from "art-template"
-import fs from "fs-extra"
-import path  from "node:path"
-import { promisify }   from "flex-tools/func/promisify"
-import logsets from "logsets" 
-/**
- * 
- * 在控制台输出一个字符串
- * 本方法会将字符串中的每一行空格去掉
- * 
- * @remarks
- * 
- * outputStr(String.raw`
- *     a
- *       b`)
- * 
- * 会输出
- * a
- *   b
- *
- * 此功能可以用于输出多行字符串时，保持代码的缩进格式，而不会影响输出结果
- * 
- * @param str : 要输出的字符串
- * @param vars : 用于替换字符串中的变量
- * 
- */
-export function outputStr(str:string,vars?:Record<string,any> | any[]){ 
-    logsets.log(fixIndent(str),vars)
-}
-
-/**
- * 修正多行字符串的缩进
- * 
- * @param text 
- * @param indent 
- * @returns 
- */
-export function fixIndent(text:string,indent?:boolean | number):string{
-    let indentValue = (indent==undefined || indent===true) ? 0 : (typeof(indent)=='number' ? indent : -1)
-    if(indentValue==-1) return text // 不修正缩进
-    let lines:string[] = text.split("\n")
-    let minSpaceCount = lines.reduce<number>((minCount,line,index)=>{
-        if(index==0) return minCount
-        const spaceCount = line.match(/^\s*/)?.[0].length || 0
-        return Math.min(minCount,spaceCount)
-    },9999)
-    lines = lines.map(line=>line.substring(minSpaceCount))
-    return lines.join("\n")
-}
-
-/**
- * 增加内置选项
- * @param command 
- */
-export function addBuiltInOptions(command:any){    
-    command.option("--work-dirs <values...>","指定工作目录",{hidden:true,optional:true,required:true,prompt:false})
-    command.option("--disable-prompts","禁用所有交互提示",{hidden:true,prompt:false}) 
-    command.option("--debug-cli","显示调试信息",{hidden:true,prompt:false})
-}
-
-
-/**
- * 是否命令行中包含了--debug-cli选项
- */
-export function isDebug(){
-    return process.argv.includes("--debug-cli")
-}
-export function isEnablePrompts(){    
-    return !process.argv.includes("--disable-prompts")
-}
-
-/**
- * 打印调试信息
- * @param message 
- * @param args 
- */
-export function outputDebug(message:string,...args:any[]){    
-    let vars = (args.length == 1 && typeof(args[0])=='function') ? args[0]() : args
-    if(isDebug()) logsets.log(`[MixCli] ${message}`,...vars)
-}
-
-export const fileExists = promisify(fs.exists,{
-    parseCallback:(results)=>{
-        return results[0]
-    }
-})
-export const readFile = promisify(fs.readFile)
-export const writeFile = promisify(fs.writeFile)
-export const mkdir = promisify(fs.mkdir)
-
-/**
- * 基于artTemplate模板生成文件
- * 
- * @param {*} tmplFile 
- * @param {*} vars 
- */
-export async function createFileByTemplate(targetFile:string,tmplFile:string,vars:Record<string,any>={}){
-    tmplFile=path.isAbsolute(tmplFile)? tmplFile : path.join(process.cwd(),tmplFile)
-    if(!fs.existsSync(tmplFile)){
-        throw new Error("模板文件不存在:"+tmplFile)
-    }
-    targetFile=path.isAbsolute(targetFile)? targetFile : path.join(process.cwd(),targetFile)
-    const outPath = path.dirname(targetFile)
-    if(!await fileExists(outPath)){
-        await mkdir(outPath,{recursive:true})
-    }    
-    const template = artTemplate(tmplFile,await readFile(tmplFile,{encoding:"utf-8"}));    
-    await writeFile(targetFile,template(vars),{encoding:"utf-8"})
-    return targetFile
-}
-
-/**  
- * 创建目录  
- * 
- *  
- * 
- * @param {String[]} dirs 要创建的目录列表，类型为字符串数组  
- * @param callback      创建目录过程中的回调函数，类型为异步函数，接收一个参数 dir，表示当前正在创建的目录  
- * @returns 该函数返回一个 Promise 对象，表示创建目录的操作是否完成  
- */
-export async function mkDirs(dirs:string[],{callback,base}:{callback?:Function,base?:string}){
-    if(!Array.isArray(dirs)) throw new Error("dirs参数必须为字符串数组")
-    for(let dir of dirs){
-        if(!path.isAbsolute(dir)) dir = path.join(base || process.cwd(),dir)
-        if(typeof(callback)=='function') callback(dir)
-        await mkdir(dir,{recursive:true})
-    }
-}
-
-export function showError(e:any){
-    if(isDebug()){
-        outputDebug("导入命令<>出错:{}",e.stack)
-    }else{
-        console.error(e)
-    }  
-
-}
-
-
-export function getId(){
-    return Math.random().toString(36).substr(2)
-}
-
-
-export async function importModule(file:string){
-    let module 
-    try{
-        module = require(file)
-    }catch(e:any){
-        try{
-            const cmd = await import(`file://${file}`)
-            module = cmd.default
-        }catch(e:any){
-            throw e
-        }        
-    }
-    return module
-}
+import fs from "fs-extra"
+import path  from "node:path"
+import { promisify }   from "flex-tools/func/promisify"
+import logsets from "logsets" 
+
+
+/**
+ * 
+ * 在控制台输出一个字符串
+ * 本方法会将字符串中的每一行空格去掉
+ * 
+ * @remarks
+ * 
+ * outputStr(String.raw`
+ *     a
+ *       b`)
+ * 
+ * 会输出
+ * a
+ *   b
+ *
+ * 此功能可以用于输出多行字符串时，保持代码的缩进格式，而不会影响输出结果
+ * 
+ * @param str : 要输出的字符串
+ * @param vars : 用于替换字符串中的变量
+ * 
+ */
+export function outputStr(str:string,vars?:Record<string,any> | any[]){ 
+    logsets.log(fixIndent(str),vars)
+}
+
+/**
+ * 修正多行字符串的缩进
+ * 
+ * @param text 
+ * @param indent 
+ * @returns 
+ */
+export function fixIndent(text:string,indent?:boolean | number):string{
+    let indentValue = (indent==undefined || indent===true) ? 0 : (typeof(indent)=='number' ? indent : -1)
+    if(indentValue==-1) return text // 不修正缩进
+    let lines:string[] = text.split("\n")
+    let minSpaceCount = lines.reduce<number>((minCount,line,index)=>{
+        if(index==0) return minCount
+        const spaceCount = line.match(/^\s*/)?.[0].length || 0
+        return Math.min(minCount,spaceCount)
+    },9999)
+    lines = lines.map(line=>line.substring(minSpaceCount))
+    return lines.join("\n")
+}
+
+/**
+ * 增加内置选项
+ * @param command 
+ */
+export function addBuiltInOptions(command:any){    
+    command.option("--work-dirs <values...>","指定工作目录",{hidden:true,optional:true,required:true,prompt:false})
+    command.option("--disable-prompts","禁用所有交互提示",{hidden:true,prompt:false}) 
+    command.option("--debug-cli","显示调试信息",{hidden:true,prompt:false})
+}
+
+
+/**
+ * 是否命令行中包含了--debug-cli选项
+ */
+export function isDebug(){
+    return process.argv.includes("--debug-cli")
+}
+
+
+export function isDisablePrompts(){    
+    return process.argv.includes("--disable-prompts")
+}
+
+/**
+ * 打印调试信息
+ * @param message 
+ * @param args 
+ */
+export function outputDebug(message:string,...args:any[]){    
+    let vars = (args.length == 1 && typeof(args[0])=='function') ? args[0]() : args
+    if(isDebug()) logsets.log(`[MixCli] ${message}`,...vars)
+}
+
+export const fileExists = promisify(fs.exists,{
+    parseCallback:(results)=>{
+        return results[0]
+    }
+})
+export const readFile = promisify(fs.readFile)
+export const writeFile = promisify(fs.writeFile)
+export const mkdir = promisify(fs.mkdir)
+ 
+/**  
+ * 创建目录  
+ * 
+ *  
+ * 
+ * @param {String[]} dirs 要创建的目录列表，类型为字符串数组  
+ * @param callback      创建目录过程中的回调函数，类型为异步函数，接收一个参数 dir，表示当前正在创建的目录  
+ * @returns 该函数返回一个 Promise 对象，表示创建目录的操作是否完成  
+ */
+export async function mkDirs(dirs:string[],{callback,base}:{callback?:Function,base?:string}){
+    if(!Array.isArray(dirs)) throw new Error("dirs参数必须为字符串数组")
+    for(let dir of dirs){
+        if(!path.isAbsolute(dir)) dir = path.join(base || process.cwd(),dir)
+        if(typeof(callback)=='function') callback(dir)
+        await mkdir(dir,{recursive:true})
+    }
+}
+
+export function showError(e:any){
+    if(isDebug()){
+        outputDebug("导入命令<>出错:{}",e.stack)
+    }else{
+        console.error(e)
+    }  
+
+}
+
+// 编写一个函数，用于将使用-分隔的字符串转换为驼峰式
+export function hyphenToCamelCase(str:string){
+    return str.replace(/-([a-z])/g,(_,letter)=>letter.toUpperCase())
+}
+
+export function getId(){
+    return Math.random().toString(36).substr(2)
+}
+
+
+export async function importModule(file:string){
+    let module 
+    try{
+        module = require(file)
+    }catch(e:any){
+        try{
+            const cmd = await import(`file://${file}`)
+            module = cmd.default
+        }catch(e:any){
+            throw e
+        }        
+    }
+    return module
+}