@lakutata/cli 1.0.37 → 2.1.0-alpha.4

package/src/lib/manipulators/application/ApplicationIndexManipulator.ts

@@ -1,169 +0,0 @@
-import {
-    Identifier,
-    ObjectLiteralExpression,
-    Project,
-    PropertyAssignment,
-    SourceFile, StructureKind,
-    Symbol
-} from 'ts-morph'
-
-/**
- * 更新项目索引
- * @param projectPath
- * @param tsConfigFilePath
- * @param configuration
- * @constructor
- */
-export async function ApplicationIndexManipulator(projectPath: string, tsConfigFilePath: string, configuration: string) {
-    const project = new Project({
-        tsConfigFilePath: tsConfigFilePath
-    })
-    project.addSourceFilesAtPaths(projectPath)
-    if (!project.getSourceFile(configuration)) return console.error('项目读取错误: 项目配置文件未找到')
-    const configFile: SourceFile = project.getSourceFile(configuration) as SourceFile
-    const moduleDeclaration = configFile.getModule(`'@lakutata/core'`)
-    if (!moduleDeclaration) return console.error('项目读取错误: 模块声明未找到')
-    const configFunction = configFile.getFunction('Config')
-    if (!configFunction) return console.error('项目读取错误: 配置方法未找到')
-    const applicationInterface = moduleDeclaration.getInterface('Application')
-    if (!applicationInterface) return console.error('项目读取错误: 程序声明未找到')
-    moduleDeclaration.removeBody()
-    const componentMap: Map<string, string> = new Map()
-    const moduleMap: Map<string, string> = new Map()
-    configFunction.getChildren().forEach(node => {
-        if (node.getKindName() === 'Block') {
-            node.getDescendantStatements().forEach(statement => {
-                if (statement.getKindName() === 'ReturnStatement') {
-                    statement.forEachChild(childNode => {
-                        if (childNode.getKindName() === 'ObjectLiteralExpression') {
-                            const OLE: ObjectLiteralExpression = childNode as ObjectLiteralExpression
-                            if (OLE.getProperty('components')) {
-                                const components: PropertyAssignment = OLE.getProperty('components') as PropertyAssignment
-                                components.forEachChild(componentNode => {
-                                    if (componentNode.getKindName() === 'ObjectLiteralExpression') {
-                                        const COLE: ObjectLiteralExpression = componentNode as ObjectLiteralExpression
-                                        COLE.forEachChild(COLENode => {
-                                            const COLENodePropertyAssignment: PropertyAssignment = COLENode as PropertyAssignment
-                                            //组件名称
-                                            let componentName: string | null = null
-                                            let componentClassName: string | null = null
-                                            COLENodePropertyAssignment.forEachChild(COLENodePropertyAssignmentNode => {
-                                                if (COLENodePropertyAssignmentNode.getKindName() === 'Identifier') {
-                                                    const identifier: Identifier = COLENodePropertyAssignmentNode as Identifier
-                                                    const symbol = identifier.getSymbol() as Symbol
-                                                    if (!componentName) {
-                                                        //获取组件名称
-                                                        componentName = symbol.getName()
-                                                    } else {
-                                                        //获取组件类名
-                                                        componentClassName = symbol.getName()
-                                                    }
-                                                } else if (COLENodePropertyAssignmentNode.getKindName() === 'ObjectLiteralExpression') {
-                                                    const componentObjectLiteralExpression: ObjectLiteralExpression = COLENodePropertyAssignmentNode as ObjectLiteralExpression
-                                                    componentObjectLiteralExpression.forEachChild(item => {
-                                                        if (item.getKindName() === 'PropertyAssignment') {
-                                                            const componentConfigItem: PropertyAssignment = item as PropertyAssignment
-                                                            const keyName = (componentConfigItem.getSymbol() as Symbol).getName()
-                                                            if (keyName === 'class') {
-                                                                const initializer = componentConfigItem.getStructure().initializer
-                                                                if (typeof initializer === 'string') {
-                                                                    componentClassName = initializer
-                                                                }
-                                                            }
-                                                        }
-                                                    })
-                                                }
-                                            })
-                                            if (componentName && componentClassName) {
-                                                componentMap.set(componentName, componentClassName)
-                                            }
-                                        })
-                                    }
-                                })
-                            }
-                            if (OLE.getProperty('modules')) {
-                                const modules: PropertyAssignment = OLE.getProperty('modules') as PropertyAssignment
-                                modules.forEachChild(moduleNode => {
-                                    if (moduleNode.getKindName() === 'ObjectLiteralExpression') {
-                                        const MOLE: ObjectLiteralExpression = moduleNode as ObjectLiteralExpression
-                                        MOLE.forEachChild(MOLENode => {
-                                            const MOLENodePropertyAssignment: PropertyAssignment = MOLENode as PropertyAssignment
-                                            //模块名称
-                                            let moduleName: string | null = null
-                                            let moduleClassName: string | null = null
-                                            MOLENodePropertyAssignment.forEachChild(MOLENodePropertyAssignmentNode => {
-                                                if (MOLENodePropertyAssignmentNode.getKindName() === 'Identifier') {
-                                                    //获取模块名称
-                                                    const identifier: Identifier = MOLENodePropertyAssignmentNode as Identifier
-                                                    const symbol = identifier.getSymbol() as Symbol
-                                                    moduleName = symbol.getName()
-                                                } else if (MOLENodePropertyAssignmentNode.getKindName() === 'ObjectLiteralExpression') {
-                                                    const moduleObjectLiteralExpression: ObjectLiteralExpression = MOLENodePropertyAssignmentNode as ObjectLiteralExpression
-                                                    moduleObjectLiteralExpression.forEachChild(item => {
-                                                        if (item.getKindName() === 'PropertyAssignment') {
-                                                            const moduleConfigItem: PropertyAssignment = item as PropertyAssignment
-                                                            const keyName = (moduleConfigItem.getSymbol() as Symbol).getName()
-                                                            if (keyName === 'class') {
-                                                                const initializer = moduleConfigItem.getStructure().initializer
-                                                                if (typeof initializer === 'string') {
-                                                                    moduleClassName = initializer
-                                                                }
-                                                            }
-                                                        }
-                                                    })
-                                                }
-                                            })
-                                            if (moduleName && moduleClassName) {
-                                                moduleMap.set(moduleName, moduleClassName)
-                                            }
-                                        })
-                                    }
-                                })
-                            }
-                        }
-                    })
-                }
-            })
-        }
-    })
-    moduleDeclaration.addStatements([{
-        kind: StructureKind.Interface,
-        name: 'Application',
-        properties: [
-            {
-                name: 'Components()',
-                kind: StructureKind.PropertySignature,
-                leadingTrivia: 'get ',
-                type: writer => {
-                    writer.block(() => {
-                        writer.writeLine('get:<T extends Component = Component>(name: string) => T')
-                        writer.writeLine('has:(name:string)=>boolean')
-                        componentMap.forEach((componentClassName, componentName) => {
-                            writer.writeLine(`${componentName}:${componentClassName}`)
-                        })
-                    })
-                }
-            },
-            {
-                name: 'Modules()',
-                kind: StructureKind.PropertySignature,
-                leadingTrivia: 'get ',
-                type: writer => {
-                    writer.block(() => {
-                        writer.writeLine('get:<T extends Module = Module>(name: string) => T')
-                        writer.writeLine('has:(name:string)=>boolean')
-                        moduleMap.forEach((moduleClassName, moduleName) => {
-                            writer.writeLine(`${moduleName}:${moduleClassName}`)
-                        })
-                    })
-                }
-            }
-        ]
-    }])
-    try {
-        await project.save()
-        console.info('索引更新成功')
-    } catch (e) {
-        console.error(`索引更新出错: ${(e as Error).message}`)
-    }
-}

package/src/lib/menus/MainMenu.ts

@@ -1,148 +0,0 @@
-import inquirer from 'inquirer'
-import {InitializeApplicationProject} from './initializeMenus/InitializeApplicationProject'
-import {InitializeModuleProject} from './initializeMenus/InitializeModuleProject'
-import {InitializeComponentProject} from './initializeMenus/InitializeComponentProject'
-import {InitializePluginProject} from './initializeMenus/InitializePluginProject'
-import {gt} from 'semver'
-import path from 'path'
-import fs from 'fs'
-import {ManipulateApplicationProject} from './manipulateMenus/ManipulateApplicationProject'
-import {ManipulateModuleProject} from './manipulateMenus/ManipulateModuleProject'
-import {ManipulateComponentProject} from './manipulateMenus/ManipulateComponentProject'
-import {ManipulatePluginProject} from './manipulateMenus/ManipulatePluginProject'
-import { LatestVersion } from '../LatestVersion'
-
-export async function MainMenu(packageJson: any) {
-    const mainMenuOpt = await inquirer.prompt([{
-        name: 'opr',
-        message: `请选择需要进行的操作 (Lakutata CLI ${packageJson.version})`,
-        type: 'list',
-        choices: [
-            {
-                name: '创建Lakutata项目',
-                value: 'initialize'
-            },
-            {
-                name: '编辑Lakutata项目',
-                value: 'manipulate'
-            },
-            {
-                name: '关于Lakutata CLI',
-                value: 'about'
-            },
-            {
-                name: '检查更新',
-                value: 'check-update'
-            }
-        ]
-    }])
-    switch (mainMenuOpt.opr) {
-        case 'initialize': {
-            const initializeProjectOption = await inquirer.prompt([
-                {
-                    name: 'type',
-                    message: '请选择生成的项目类型',
-                    type: 'list',
-                    choices: [
-                        {
-                            name: '应用程序',
-                            value: 'application'
-                        },
-                        {
-                            name: '模块',
-                            value: 'module'
-                        },
-                        {
-                            name: '组件',
-                            value: 'component'
-                        },
-                        {
-                            name: '插件',
-                            value: 'plugin'
-                        }
-                    ]
-                }, {
-                    name: 'path',
-                    message: '项目生成地址',
-                    type: 'input',
-                    default: process.cwd()
-                }
-            ])
-            const projectPath: string = initializeProjectOption.path
-            switch (initializeProjectOption.type) {
-                case 'application': {
-                    return await InitializeApplicationProject(projectPath)
-                }
-                case 'module': {
-                    return await InitializeModuleProject(projectPath)
-                }
-                case 'component': {
-                    return await InitializeComponentProject(projectPath)
-                }
-                case 'plugin': {
-                    return await InitializePluginProject(projectPath)
-                }
-                default: {
-                    console.warn('不正确的项目类型:', initializeProjectOption.type)
-                }
-            }
-        }
-            break
-        case 'manipulate': {
-            const projectPath: string = process.cwd()
-            const packageJsonPath: string = path.resolve(projectPath, './package.json')
-            const tsconfigJsonPath: string = path.resolve(projectPath, './tsconfig.json')
-            if (!fs.existsSync(packageJsonPath)) {
-                return console.error('项目信息读取错误: 请在项目根目录执行该指令')
-            }
-            try {
-                const projectPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, {encoding: 'utf-8'}))
-                if (projectPackageJson.lakutata && projectPackageJson.lakutata.type) {
-                    const projectType: 'application' | 'module' | 'component' | 'plugin' = projectPackageJson.lakutata.type
-                    switch (projectType) {
-                        case 'application': {
-                            return await ManipulateApplicationProject(projectPath, tsconfigJsonPath, projectPackageJson.lakutata)
-                        }
-                        case 'module': {
-                            return await ManipulateModuleProject(projectPath, tsconfigJsonPath, projectPackageJson.lakutata)
-                        }
-                        case 'component': {
-                            return await ManipulateComponentProject(projectPath, tsconfigJsonPath, projectPackageJson.lakutata)
-                        }
-                        case 'plugin': {
-                            return ManipulatePluginProject(projectPath, tsconfigJsonPath, projectPackageJson.lakutata)
-                        }
-                        default: {
-                            return console.error(`项目信息读取错误: 无效的项目类型[${projectType}]`)
-                        }
-                    }
-                } else {
-                    return console.error('项目信息读取错误: 无法操作非Lakutata框架的项目')
-                }
-            } catch (e) {
-                return console.error(`项目信息读取错误: ${(e as Error).message}`)
-            }
-            return
-        }
-        case 'about': {
-            console.log('Lakutata CLI - Lakutata框架辅助工具')
-            console.log('Version:', packageJson.version)
-            console.log('Powered by Lakutata')
-            return
-        }
-        case 'check-update': {
-            try {
-                const localVersion: string = packageJson.version
-                const npmVersion: string = await LatestVersion(packageJson.name.toString())
-                if (gt(npmVersion, localVersion)) {
-                    console.info('有可用更新:', localVersion, '➡', npmVersion)
-                    console.info('执行', `npm install -g ${packageJson.name}`, '进行更新')
-                } else {
-                    console.info('无可用更新')
-                }
-            } catch (e) {
-                console.error(`检查更新失败: ${(e as Error).message}`)
-            }
-        }
-    }
-}

package/src/lib/menus/initializeMenus/InitializeApplicationProject.ts

@@ -1,84 +0,0 @@
-import inquirer from 'inquirer'
-import {ApplicationGenerator} from '../../generators/application/ApplicationGenerator'
-import {LicenseList} from '../../../constants/LicenseList'
-import shell from 'shelljs'
-
-export async function InitializeApplicationProject(projectPath: string) {
-    const options = await inquirer.prompt([
-        {
-            name: 'id',
-            message: '请输入应用的ID[例如:identifier.scope.app]',
-            type: 'input'
-        },
-        {
-            name: 'name',
-            message: '请输入应用名称',
-            type: 'input'
-        },
-        {
-            name: 'author',
-            message: '请输入作者名称',
-            type: 'input'
-        },
-        {
-            name: 'description',
-            message: '请输入应用说明',
-            type: 'input'
-        },
-        {
-            name: 'keywords',
-            message: '请输入应用关键词(使用逗号分隔)',
-            type: 'input'
-        },
-        {
-            name: 'license',
-            message: '请选择应用开源许可协议',
-            type: 'list',
-            default: 'UNLICENSED',
-            choices: LicenseList
-        }
-    ])
-    console.info('==================================================')
-    console.info('项目目录:', projectPath)
-    console.info('应用的ID:', options.id)
-    console.info('应用名称:', options.name)
-    console.info('作者名称:', options.author)
-    console.info('应用说明:', options.description)
-    console.info('关键词:', options.keywords)
-    console.info('开源许可协议:', options.license)
-    console.info('==================================================')
-    const confirmResult = await inquirer.prompt([
-        {
-            name: 'confirm',
-            message: '请确认信息是否填写正确',
-            type: 'confirm',
-            default: 'Y'
-        }
-    ])
-    if (confirmResult.confirm) {
-        const applicationProject = new ApplicationGenerator({
-            id: options.id,
-            name: options.name,
-            author: options.author,
-            license: options.license,
-            description: options.description,
-            keywords: (() => {
-                if (options.keywords) {
-                    return options.keywords.toString().split(',')
-                } else {
-                    return []
-                }
-            })(),
-            path: projectPath
-        })
-        try {
-            console.info('正在生成项目文件')
-            await applicationProject.generate()
-            console.info('项目文件生成成功')
-            shell.cd(projectPath).exec('npm install --build-from-source --unsafe-perm', {silent: true, async: false})
-            console.info('应用初始化完成!')
-        } catch (e) {
-            console.error(`项目生成错误: ${(e as Error).message}`)
-        }
-    }
-}

package/src/lib/menus/initializeMenus/InitializeComponentProject.ts

@@ -1,84 +0,0 @@
-import inquirer from 'inquirer'
-import {ComponentGenerator} from '../../generators/component/ComponentGenerator'
-import {LicenseList} from '../../../constants/LicenseList'
-import shell from 'shelljs'
-
-export async function InitializeComponentProject(projectPath: string) {
-    const options = await inquirer.prompt([
-        {
-            name: 'className',
-            message: '请输入组件名称',
-            type: 'input'
-        },
-        {
-            name: 'name',
-            message: '请输入项目名称',
-            type: 'input'
-        },
-        {
-            name: 'author',
-            message: '请输入作者名称',
-            type: 'input'
-        },
-        {
-            name: 'description',
-            message: '请输入项目说明',
-            type: 'input'
-        },
-        {
-            name: 'keywords',
-            message: '请输入项目关键词(使用逗号分隔)',
-            type: 'input'
-        },
-        {
-            name: 'license',
-            message: '请选择项目开源许可协议',
-            type: 'list',
-            default: 'UNLICENSED',
-            choices: LicenseList
-        }
-    ])
-    console.info('==================================================')
-    console.info('项目目录:', projectPath)
-    console.info('组件名称:', options.className)
-    console.info('项目名称:', options.name)
-    console.info('作者名称:', options.author)
-    console.info('项目说明:', options.description)
-    console.info('关键词:', options.keywords)
-    console.info('开源许可协议:', options.license)
-    console.info('==================================================')
-    const confirmResult = await inquirer.prompt([
-        {
-            name: 'confirm',
-            message: '请确认信息是否填写正确',
-            type: 'confirm',
-            default: 'Y'
-        }
-    ])
-    if (confirmResult.confirm) {
-        const componentGenerator = new ComponentGenerator({
-            className: options.className,
-            name: options.name,
-            author: options.author,
-            license: options.license,
-            description: options.description,
-            keywords: (() => {
-                if (options.keywords) {
-                    return options.keywords.toString().split(',')
-                } else {
-                    return []
-                }
-            })(),
-            path: projectPath
-        })
-        try {
-            console.info('正在生成项目文件')
-            await componentGenerator.generate()
-            console.info('项目文件生成成功')
-            shell.cd(projectPath).exec('npm install --build-from-source --unsafe-perm', {silent: true, async: false})
-            console.info('应用初始化完成!')
-        } catch (e) {
-            console.error(`项目生成错误: ${(e as Error).message}`)
-        }
-    }
-}

package/src/lib/menus/initializeMenus/InitializeModuleProject.ts

@@ -1,84 +0,0 @@
-import inquirer from 'inquirer'
-import {LicenseList} from '../../../constants/LicenseList'
-import {ModuleGenerator} from '../../generators/module/ModuleGenerator'
-import shell from 'shelljs'
-
-export async function InitializeModuleProject(projectPath: string) {
-    const options = await inquirer.prompt([
-        {
-            name: 'className',
-            message: '请输入模块名称',
-            type: 'input'
-        },
-        {
-            name: 'name',
-            message: '请输入项目名称',
-            type: 'input'
-        },
-        {
-            name: 'author',
-            message: '请输入作者名称',
-            type: 'input'
-        },
-        {
-            name: 'description',
-            message: '请输入项目说明',
-            type: 'input'
-        },
-        {
-            name: 'keywords',
-            message: '请输入项目关键词(使用逗号分隔)',
-            type: 'input'
-        },
-        {
-            name: 'license',
-            message: '请选择项目开源许可协议',
-            type: 'list',
-            default: 'UNLICENSED',
-            choices: LicenseList
-        }
-    ])
-    console.info('==================================================')
-    console.info('项目目录:', projectPath)
-    console.info('模块名称:', options.className)
-    console.info('项目名称:', options.name)
-    console.info('作者名称:', options.author)
-    console.info('项目说明:', options.description)
-    console.info('关键词:', options.keywords)
-    console.info('开源许可协议:', options.license)
-    console.info('==================================================')
-    const confirmResult = await inquirer.prompt([
-        {
-            name: 'confirm',
-            message: '请确认信息是否填写正确',
-            type: 'confirm',
-            default: 'Y'
-        }
-    ])
-    if (confirmResult.confirm) {
-        const moduleGenerator = new ModuleGenerator({
-            className: options.className,
-            name: options.name,
-            author: options.author,
-            license: options.license,
-            description: options.description,
-            keywords: (() => {
-                if (options.keywords) {
-                    return options.keywords.toString().split(',')
-                } else {
-                    return []
-                }
-            })(),
-            path: projectPath
-        })
-        try {
-            console.info('正在生成项目文件')
-            await moduleGenerator.generate()
-            console.info('项目文件生成成功')
-            shell.cd(projectPath).exec('npm install --build-from-source --unsafe-perm', {silent: true, async: false})
-            console.info('应用初始化完成!')
-        } catch (e) {
-            console.error(`项目生成错误: ${(e as Error).message}`)
-        }
-    }
-}

package/src/lib/menus/initializeMenus/InitializePluginProject.ts

@@ -1,84 +0,0 @@
-import inquirer from 'inquirer'
-import {LicenseList} from '../../../constants/LicenseList'
-import {PluginGenerator} from '../../generators/plugin/PluginGenerator'
-import shell from 'shelljs'
-
-export async function InitializePluginProject(projectPath: string) {
-    const options = await inquirer.prompt([
-        {
-            name: 'className',
-            message: '请输入插件名称',
-            type: 'input'
-        },
-        {
-            name: 'name',
-            message: '请输入项目名称',
-            type: 'input'
-        },
-        {
-            name: 'author',
-            message: '请输入作者名称',
-            type: 'input'
-        },
-        {
-            name: 'description',
-            message: '请输入项目说明',
-            type: 'input'
-        },
-        {
-            name: 'keywords',
-            message: '请输入项目关键词(使用逗号分隔)',
-            type: 'input'
-        },
-        {
-            name: 'license',
-            message: '请选择项目开源许可协议',
-            type: 'list',
-            default: 'UNLICENSED',
-            choices: LicenseList
-        }
-    ])
-    console.info('==================================================')
-    console.info('项目目录:', projectPath)
-    console.info('插件名称:', options.className)
-    console.info('项目名称:', options.name)
-    console.info('作者名称:', options.author)
-    console.info('项目说明:', options.description)
-    console.info('关键词:', options.keywords)
-    console.info('开源许可协议:', options.license)
-    console.info('==================================================')
-    const confirmResult = await inquirer.prompt([
-        {
-            name: 'confirm',
-            message: '请确认信息是否填写正确',
-            type: 'confirm',
-            default: 'Y'
-        }
-    ])
-    if (confirmResult.confirm) {
-        const pluginGenerator = new PluginGenerator({
-            className: options.className,
-            name: options.name,
-            author: options.author,
-            license: options.license,
-            description: options.description,
-            keywords: (() => {
-                if (options.keywords) {
-                    return options.keywords.toString().split(',')
-                } else {
-                    return []
-                }
-            })(),
-            path: projectPath
-        })
-        try {
-            console.info('正在生成项目文件')
-            await pluginGenerator.generate()
-            console.info('项目文件生成成功')
-            shell.cd(projectPath).exec('npm install --build-from-source --unsafe-perm', {silent: true, async: false})
-            console.info('应用初始化完成!')
-        } catch (e) {
-            console.error(`项目生成错误: ${(e as Error).message}`)
-        }
-    }
-}