mixcli 3.0.1 → 3.0.2

package/src/oslocate.js

@@ -0,0 +1,148 @@
+// fork from https://github.com/sindresorhus/os-locale
+const lcid = require('lcid')
+const {exec, execSync} = require('./utils.js')
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+const defaultOptions = {spawn: true};
+const defaultLocale = 'en-US';
+
+async function getStdOut(command, args) {
+	return (await exec(command, args)).stdout;
+}
+
+function getStdOutSync(command, args) {
+	return execSync(command, args);
+}
+
+function getEnvLocale(env = process.env) {
+	return env.LC_ALL || env.LC_MESSAGES || env.LANG || env.LANGUAGE;
+}
+
+function parseLocale(string) {
+	const env = {};
+	for (const definition of string.split('\n')) {
+		const [key, value] = definition.split('=');
+		env[key] = value.replace(/^"|"$/g, '');
+	}
+
+	return getEnvLocale(env);
+}
+
+function getLocale(string) {
+	return (string && string.replace(/[.:].*/, ''));
+}
+
+async function getLocales() {
+	return getStdOut('locale', ['-a']);
+}
+
+function getLocalesSync() {
+	return getStdOutSync('locale', ['-a']);
+}
+
+function getSupportedLocale(locale, locales = '') {
+	return locales.includes(locale) ? locale : defaultLocale;
+}
+
+async function getAppleLocale() {
+	const results = await Promise.all([
+		getStdOut('defaults', ['read', '-globalDomain', 'AppleLocale']),
+		getLocales(),
+	]);
+
+	return getSupportedLocale(results[0], results[1]);
+}
+
+function getAppleLocaleSync() {
+	return getSupportedLocale(
+		getStdOutSync('defaults', ['read', '-globalDomain', 'AppleLocale']),
+		getLocalesSync(),
+	);
+}
+
+async function getUnixLocale() {
+	return getLocale(parseLocale(await getStdOut('locale')));
+}
+
+function getUnixLocaleSync() {
+	return getLocale(parseLocale(getStdOutSync('locale')));
+}
+
+async function getWinLocale() {
+	const stdout = await getStdOut('wmic', ['os', 'get', 'locale']);
+	const lcidCode = Number.parseInt(stdout.replace('Locale', ''), 16);
+
+	return lcid.from(lcidCode);
+}
+
+function getWinLocaleSync() {
+	const stdout = getStdOutSync('wmic', ['os', 'get', 'locale']);
+	const lcidCode = Number.parseInt(stdout.replace('Locale', ''), 16);
+
+	return lcid.from(lcidCode);
+}
+
+function normalise(input) {
+	return input.replace(/_/, '-');
+}
+
+const cache = new Map();
+ 
+
+function osLocaleSync(options = defaultOptions) {
+	if (cache.has(options.spawn)) {
+		return cache.get(options.spawn);
+	}
+
+	let locale;
+	try {
+		const envLocale = getEnvLocale();
+
+		if (envLocale || options.spawn === false) {
+			locale = getLocale(envLocale);
+		} else if (process.platform === 'win32') {
+			locale = getWinLocaleSync();
+		} else if (process.platform === 'darwin') {
+			locale = getAppleLocaleSync();
+		} else {
+			locale = getUnixLocaleSync();
+		}
+	} catch {}
+
+	const normalised = normalise(locale || defaultLocale);
+	cache.set(options.spawn, normalised);
+	return normalised;
+}
+
+
+function getCliLanguage(){
+    const supportedLanguages = require("./languages/settings.json").languages
+    const savedLangFile = path.join(os.tmpdir(),"voerkai18n_cli_language")
+    let result 
+    const envLang = process.env.LANGUAGE;
+    if(envLang){
+        result = envLang.trim()
+    }else{
+        if(fs.existsSync(savedLangFile)){
+            try{
+				result = fs.readFileSync(savedLangFile).trim()
+			}catch{}
+        }
+        if(!result || !supportedLanguages.some(lng=>lng.name==result) ){
+            result = osLocaleSync()
+            result = result.split("-")[0]            
+        }         
+    }
+    if(!supportedLanguages.some(lng=>lng.name==result) ){
+        result = "en"
+    }
+    // 记住上次使用的语言
+    fs.writeFileSync(savedLangFile,result)
+    return result
+}
+
+
+module.exports = {
+    getCliLanguage
+}

package/src/prompt.ts

@@ -0,0 +1,180 @@
+import { PromptObject } from "prompts" 
+import { outputDebug } from "./utils"
+ 
+
+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",                        
+} 
+
+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;
+    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{
+   
+
+}
+
+
+/**
+ * 负责生成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
+    }
+
+    /**
+     * 返回输入的是否是有效的prompt类型
+     * @param type 
+     * @returns 
+     */
+    isValid(type:any){
+        return  supportedPromptTypes.includes(String(type))
+    }
+    /**
+     * 推断是否需要提示
+     * 
+     */
+    isNeed(input:any,defaultValue?:any){
+    
+        const promptArg = this.args
+        const inputValue = input || defaultValue
+        // 是否有输入值，即在命令行输入了值
+        const hasInput = !(inputValue === undefined)
+        // 1. 显式指定了_prompt为true，则需要提示，后续进行提示类型的推断，可能不会准确
+        if(promptArg===true) return true
+        if(promptArg===false) return false        
+
+        // 2. 提供了一个prompt对象，并且没有在命令行输入值，则需要提示
+        if(typeof(promptArg)=='object'){
+            return !hasInput
+        }
+
+        // 3. 指定了内置的prompt类型，如prompt='password'，则使用password类型提示输入
+        if(typeof(promptArg) == 'string' && supportedPromptTypes.includes(promptArg)){
+            return  !hasInput
+        }
+        
+        // 4. 判断输入是否有效，则显示提示
+        if(this._promptable.argChoices && this._promptable.argChoices.indexOf(inputValue) == -1){
+            return true
+        } 
+        return !hasInput
+    }
+    /**
+     * 返回生成prompt对象
+     * 
+     * @param inputValue   从命令行输入的值
+     */
+    get(inputValue?:any){
+        const {description,promptChoices,validate,defaultValue} = this._promptable
+        let input = inputValue || defaultValue
+        // 判断是否需要输入提示
+        if(!this.isNeed(input,defaultValue)) return
+        // 推断prompt类型
+        let promptType = this.infer(inputValue)
+        const prompt = {
+            type:promptType,                        
+            name:this._promptable.name(),
+            message:description,
+            initial: input,
+            ...typeof(this.args) == 'object' ? this.args : {}
+        } as PromptObject
+        // 指定了验证函数，用来验证输入值是否有效
+        prompt.validate = validate?.bind(this._promptable)
+        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
+        }
+        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]
+                        }
+                    }
+                }
+            }
+        }
+        outputDebug("选项<{}> -> 提示类型<{}>",[this._promptable.name(),promptType])
+        return promptType
+    }
+
+}

package/src/utils.ts

@@ -0,0 +1,128 @@
+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})
+    }
+}