@widget-js/cli 1.2.11 → 24.1.1-beta.10

package/src/index.ts

@@ -1,56 +1,65 @@
-import {Option, program} from "commander";
-import fs from "fs";
-import path from "path";
-import * as process from "process";
+import fs from 'node:fs'
+import path from 'node:path'
+import * as process from 'node:process'
+import { Option, program } from 'commander'
 
-import figlet from "figlet";
-import gradient from "gradient-string";
-import {dirname} from "dirname-filename-esm";
+import figlet from 'figlet'
+import gradient from 'gradient-string'
+import { dirname } from 'dirname-filename-esm'
 
 //
-const packageJsonPath = path.join(dirname(import.meta), "../package.json");
-let cliPackage = JSON.parse(fs.readFileSync(packageJsonPath).toString());
-
-console.log(gradient.pastel.multiline(figlet.textSync("widget-cli", {horizontalLayout: "full"})));
-program.version(`@widget-js/cli ${cliPackage.version}`).usage("<command> [options]");
+const packageJsonPath = path.join(dirname(import.meta), '../package.json')
+const cliPackage = JSON.parse(fs.readFileSync(packageJsonPath).toString())
+// eslint-disable-next-line no-console
+console.log(gradient.pastel.multiline(figlet.textSync('widget-cli', { horizontalLayout: 'full' })))
+program.version(`@widget-js/cli ${cliPackage.version}`).usage('<command> [options]')
 program
-  .command("create")
-  .description("Create new widget")
+  .command('create')
+  .description('Create new widget')
   .action(async () => {
-    const createWidget = await import("./createWidget");
-    await createWidget.default();
-  });
+    const createWidget = await import('./createWidget')
+    await createWidget.default()
+  })
 
-let dependenciesOption = new Option("-t, --type <type>").choices(["remote", "local"]);
+const dependenciesOption = new Option('-t, --type <type>').choices(['remote', 'local'])
 
 program
-  .command("dependencies")
-  .description("Set @widget-js dependencies to local(workspace:*) or remote(^1.0.0 etc)")
+  .command('dependencies')
+  .description('Set @widget-js dependencies to local(workspace:*) or remote(^1.0.0 etc)')
   .addOption(dependenciesOption)
   .action(async (options) => {
-    let dependencies = await import("./dependencies/index");
-    await dependencies.default(options);
-  });
+    const dependencies = await import('./dependencies/index')
+    await dependencies.default(options)
+  })
 
 program
-  .command("init")
-  .description("Initialize widget-js project")
+  .command('init')
+  .description('Initialize widget-js project')
   .action(async () => {
-    const init = await import("./init/init");
-    await init.init();
-  });
+    const init = await import('./init/init')
+    await init.init()
+  })
 
-let typeOption = new Option("-t, --type <type>").choices(["ftp", "oss"]);
-let fileOption = new Option("-f, --file <file>");
+const keyOption = new Option('-k, --key <key>')
 program
-  .command("release")
-  .description("通过FTP/OSS发布文件，仅内部使用")
+  .command('publish')
+  .description('Publish widget package with developer key')
+  .addOption(keyOption)
+  .action(async (options) => {
+    const publishImport = await import('./publish/index')
+    await publishImport.publish(options)
+  })
+
+const typeOption = new Option('-t, --type <type>').choices(['ftp', 'oss'])
+const fileOption = new Option('-f, --file <file>')
+program
+  .command('release')
+  .description('通过FTP/OSS发布文件，仅内部使用')
   .addOption(typeOption)
   .addOption(fileOption)
-  .action(async (options, command) => {
-    // @ts-ignore
-    let release = await import("./release/release");
-    await release.default(options);
-  });
+  .action(async (options) => {
+    const release = await import('./release/release')
+    await release.default(options)
+  })
 
-program.parse(process.argv);
+program.parse(process.argv)

package/src/init/init.ts

@@ -1,119 +1,121 @@
-import {Utils} from '../utils'
-import path from 'path'
-import process from 'process'
-import fs from 'fs'
-import consola from 'consola'
-import promptChecker from '../promts/promptChecker'
-import chalk from 'chalk'
-import {EJSUtils} from '../utils/EJSUtils'
-import ora from 'ora'
-import {PrettierUtils} from '../utils/PrettierUtils'
-import {scanWidgetPackage} from '@widget-js/utils'
-import {WidgetPackageUtils} from '../utils/WidgetPackageUtils'
-import {fileURLToPath} from "url";
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-const spinner = ora('Loading')
-
-export async function init() {
-  await addDependencies()
-  await addWidgetTs()
-}
-
-async function addWidgetTs() {
-  let name = await promptChecker(
-    {
-      type: 'input',
-      name: 'name',
-      message: chalk.blue('组件包 包名 （示例 cn.widget.countdown）：'),
-    },
-    answer => {
-      const name = answer.name
-      if (name == null || name === '') {
-        consola.log(chalk.red(`包名不能为空`))
-        return false
-      }
-      return true
-    },
-  )
-
-  let widgetPackageTs = path.join(process.cwd(), 'widget.package.ts')
-  if (fs.existsSync(widgetPackageTs)) {
-    spinner.info('widget.package.ts已存在，跳过')
-  } else {
-    spinner.info('创建 widget.package.ts')
-    await EJSUtils.renderToFile('WidgetPackage.ejs', widgetPackageTs, 'typescript', {name})
-  }
-
-  await addVitePlugin()
-  await createRouter()
-
-  spinner.succeed('初始化完成，请运行 npm install')
-}
-
-/**
- * 增加widget-js依赖
- */
-async function addDependencies() {
-  const packageJson = Utils.getPackageJson()
-  let dependencies = packageJson['dependencies']
-  let devDependencies = packageJson['devDependencies']
-  if (!dependencies) {
-    dependencies = {}
-  }
-  if (!devDependencies) {
-    packageJson['devDependencies'] = {}
-  }
-
-  await addDependency('@widget-js/core', dependencies)
-  await addDependency('@widget-js/vue3', dependencies)
-  await addDependency('@widget-js/vite-plugin-widget', devDependencies)
-
-  packageJson['dependencies'] = dependencies
-  packageJson['devDependencies'] = devDependencies
-
-  fs.writeFileSync(Utils.getPackagePath(), JSON.stringify(packageJson, null, 2))
-}
-
-async function addVitePlugin() {
-  spinner.info('添加 vite-plugin-widget 到 vite plugin')
-  const viteConfigPath = path.join(process.cwd(), 'vite.config.ts')
-  if (!fs.existsSync(viteConfigPath)) {
-    spinner.warn('vite.config.ts not exists')
-    return
-  }
-  let viteConfig = fs.readFileSync(viteConfigPath).toString()
-  viteConfig = `import widget from '@widget-js/vite-plugin-widget'\n` + viteConfig
-  viteConfig = viteConfig.replace('vue()', `vue(),widget()`)
-  fs.writeFileSync(viteConfigPath, await PrettierUtils.format(viteConfig, 'typescript'))
-}
-
-async function createRouter() {
-  const widgetPackage = await scanWidgetPackage()
-  if (widgetPackage) {
-    spinner.info('创建 widget-router.ts')
-    const rootDir = WidgetPackageUtils.getRootDir(widgetPackage)
-    const widgetRouterPath = path.join(rootDir, 'widget-router.ts')
-    const routerContent = fs.readFileSync(path.join(__dirname, '../template/widget-router.ts'), 'utf8')
-    fs.writeFileSync(widgetRouterPath, routerContent)
-
-    const vueRouterPath = path.join(process.cwd(), './src/router/index.ts')
-    spinner.info('修改VueRouter配置')
-    if (fs.existsSync(vueRouterPath)) {
-      let vueRouterContent = fs.readFileSync(vueRouterPath, 'utf8')
-      const importStr = `import WidgetRouter from "../widgets/widget-router";`
-      vueRouterContent = `${importStr}\n${vueRouterContent}`
-      vueRouterContent = vueRouterContent.replace('routes: [', `routes: [\n...WidgetRouter,`)
-      fs.writeFileSync(vueRouterPath, await PrettierUtils.format(vueRouterContent, 'typescript'))
-    }
-  }
-}
-
-async function addDependency(packageName: string, dependencies: any) {
-  spinner.info(`Adding dependencies ${packageName}`)
-  if (dependencies[packageName]) {
-    return
-  }
-  const remoteVersion = await Utils.getRemoteVersion(packageName)
-  dependencies[packageName] = `^${remoteVersion}`
-}
+import path from 'node:path'
+import process from 'node:process'
+import fs from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import consola from 'consola'
+import chalk from 'chalk'
+import ora from 'ora'
+import { scanWidgetPackage } from '@widget-js/utils'
+import { Utils } from '../utils'
+import promptChecker from '../promts/promptChecker'
+import { EJSUtils } from '../utils/EJSUtils'
+import { PrettierUtils } from '../utils/PrettierUtils'
+import { WidgetPackageUtils } from '../utils/WidgetPackageUtils'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const spinner = ora('Loading')
+
+export async function init() {
+  await addDependencies()
+  await addWidgetTs()
+}
+
+async function addWidgetTs() {
+  const name = await promptChecker(
+    {
+      type: 'input',
+      name: 'name',
+      message: chalk.blue('组件包 包名 （示例 cn.widget.countdown）：'),
+    },
+    (answer) => {
+      const name = answer.name
+      if (name == null || name === '') {
+        consola.log(chalk.red(`包名不能为空`))
+        return false
+      }
+      return true
+    },
+  )
+
+  const widgetPackageTs = path.join(process.cwd(), 'widget.package.ts')
+  if (fs.existsSync(widgetPackageTs)) {
+    spinner.info('widget.package.ts已存在，跳过')
+  }
+  else {
+    spinner.info('创建 widget.package.ts')
+    await EJSUtils.renderToFile('WidgetPackage.ejs', widgetPackageTs, 'typescript', { name })
+  }
+
+  await addVitePlugin()
+  await createRouter()
+
+  spinner.succeed('初始化完成，请运行 npm install')
+}
+
+/**
+ * 增加widget-js依赖
+ */
+async function addDependencies() {
+  const packageJson = Utils.getPackageJson()
+  let dependencies = packageJson.dependencies
+  const devDependencies = packageJson.devDependencies
+  if (!dependencies) {
+    dependencies = {}
+  }
+  if (!devDependencies) {
+    packageJson.devDependencies = {}
+  }
+
+  await addDependency('@widget-js/core', dependencies)
+  await addDependency('@widget-js/vue3', dependencies)
+  await addDependency('@widget-js/vite-plugin-widget', devDependencies)
+
+  packageJson.dependencies = dependencies
+  packageJson.devDependencies = devDependencies
+
+  fs.writeFileSync(Utils.getPackagePath(), JSON.stringify(packageJson, null, 2))
+}
+
+async function addVitePlugin() {
+  spinner.info('添加 vite-plugin-widget 到 vite plugin')
+  const viteConfigPath = path.join(process.cwd(), 'vite.config.ts')
+  if (!fs.existsSync(viteConfigPath)) {
+    spinner.warn('vite.config.ts not exists')
+    return
+  }
+  let viteConfig = fs.readFileSync(viteConfigPath).toString()
+  viteConfig = `import widget from '@widget-js/vite-plugin-widget'\n${viteConfig}`
+  viteConfig = viteConfig.replace('vue()', `vue(),widget()`)
+  fs.writeFileSync(viteConfigPath, await PrettierUtils.format(viteConfig, 'typescript'))
+}
+
+async function createRouter() {
+  const widgetPackage = await scanWidgetPackage()
+  if (widgetPackage) {
+    spinner.info('创建 widget-router.ts')
+    const rootDir = WidgetPackageUtils.getRootDir(widgetPackage)
+    const widgetRouterPath = path.join(rootDir, 'widget-router.ts')
+    const routerContent = fs.readFileSync(path.join(__dirname, '../template/widget-router.ts'), 'utf8')
+    fs.writeFileSync(widgetRouterPath, routerContent)
+
+    const vueRouterPath = path.join(process.cwd(), './src/router/index.ts')
+    spinner.info('修改VueRouter配置')
+    if (fs.existsSync(vueRouterPath)) {
+      let vueRouterContent = fs.readFileSync(vueRouterPath, 'utf8')
+      const importStr = `import WidgetRouter from "../widgets/widget-router";`
+      vueRouterContent = `${importStr}\n${vueRouterContent}`
+      vueRouterContent = vueRouterContent.replace('routes: [', `routes: [\n...WidgetRouter,`)
+      fs.writeFileSync(vueRouterPath, await PrettierUtils.format(vueRouterContent, 'typescript'))
+    }
+  }
+}
+
+async function addDependency(packageName: string, dependencies: any) {
+  spinner.info(`Adding dependencies ${packageName}`)
+  if (dependencies[packageName]) {
+    return
+  }
+  const remoteVersion = await Utils.getRemoteVersion(packageName)
+  dependencies[packageName] = `^${remoteVersion}`
+}

package/src/promts/promptChecker.ts

@@ -1,15 +1,17 @@
-import inquirer, {Answers, Question} from "inquirer";
+import type { Answers, Question } from 'inquirer'
+import inquirer from 'inquirer'
 
-const promptChecker = async <T extends Question>(prompt:T, checker?:(answer:any)=>boolean):Promise<any> => {
-  const answer:Answers = await inquirer.prompt([prompt]);
+async function promptChecker<T extends Question>(prompt: T, checker?: (answer: any) => boolean): Promise<any> {
+  const answer: Answers = await inquirer.prompt([prompt])
   if (checker) {
     if (checker(answer)) {
-      return answer[prompt.name!];
-    } else {
-      return promptChecker(prompt, checker);
+      return answer[prompt.name!]
+    }
+    else {
+      return promptChecker(prompt, checker)
     }
   }
-  return answer[prompt.name!];
+  return answer[prompt.name!]
 }
 
-export default promptChecker;
+export default promptChecker

package/src/publish/index.ts

@@ -0,0 +1,60 @@
+import fs from 'node:fs'
+import fastGlob from 'fast-glob'
+import axios from 'axios'
+import consola from 'consola'
+import ora from 'ora'
+/**
+ * 用fast-glob扫描运行目录下第一个 widget.json 文件
+ * 然后用axios发送post请求到 https://widgetjs.cn/api/widget/package，把key加到请求头中，把 widget.json 文件内容作为请求体
+ */
+export async function publish(options: { key: string }): Promise<void> {
+  if (!options.key) {
+    consola.error('Please provide a developer key with -k or --key option.')
+    return
+  }
+  const spinner = ora('Search widget.json').start()
+  try {
+    // Scan the current directory for the first widget.json file, ignore node_modules
+    const files = await fastGlob('**/widget.json', { onlyFiles: true, ignore: ['node_modules/**'], absolute: true })
+    if (files.length === 0) {
+      spinner.fail('No widget.json file found.')
+      return
+    }
+
+    spinner.succeed(`Widget.json found: ${files[0]}`)
+
+    const widgetPath = files[0]
+    const widgetContent = fs.readFileSync(widgetPath, 'utf-8')
+
+    const json = JSON.parse(widgetContent)
+    consola.info(`Package name:${json.name}`)
+    const widgets = json.widgets
+    consola.info(`Widget size:${widgets?.length ?? 0}`)
+
+    spinner.start('Publishing widget package...')
+    // Send a POST request to the specified URL with the widget content
+    const response = await axios.post('https://widgetjs.cn/api/v1/widget/package', json, {
+      headers: {
+        'Content-Type': 'application/json',
+        'Key': options.key,
+      },
+    })
+
+    if (response.data) {
+      if (response.data.code == 200) {
+        spinner.succeed('Widget published successfully.')
+      }
+      else {
+        spinner.fail('Failed to publish widget.')
+        consola.error(response.data.msg)
+      }
+    }
+    else {
+      spinner.fail('Empty Response')
+    }
+  }
+  catch (error) {
+    spinner.fail('Failed to publish widget.')
+    consola.error(error)
+  }
+}

package/src/release/ftp.ts

@@ -1,21 +1,21 @@
-import path from 'path'
-import fs from 'fs'
+import path from 'node:path'
+import fs from 'node:fs'
+import os from 'node:os'
+import * as process from 'node:process'
 import SSHConfig from '@widget-js/ssh-config'
-import os from 'os'
 import Client from 'ssh2-sftp-client'
 import consola from 'consola'
 import inquirer from 'inquirer'
 import ora from 'ora'
-import * as process from 'process'
-import {Utils} from '../utils'
-import {minimatch} from 'minimatch'
+import { minimatch } from 'minimatch'
+import { Utils } from '../utils'
 
 interface PasswordAnswer {
   password: string
 }
 
 async function checkParentDir(ftpClient: Client, file: string, onMkdir: (dir: string) => void) {
-  let dir = path.dirname(file)
+  const dir = path.dirname(file)
   const dirExists = await ftpClient.exists(dir)
   if (!dirExists) {
     onMkdir(dir)
@@ -26,38 +26,39 @@ async function checkParentDir(ftpClient: Client, file: string, onMkdir: (dir: st
 async function runSSH(sshConfig: Record<string, string | string[]>, releaseConfig: ReleaseConfig) {
   consola.info('run ssh:', sshConfig)
   const answer = await inquirer.prompt<PasswordAnswer>([
-    {type: 'password', name: 'password', mask: '*', message: 'Enter key pair password'},
+    { type: 'password', name: 'password', mask: '*', message: 'Enter key pair password' },
   ])
 
-  let ftpClient = new Client()
-  const port = sshConfig['Port']
+  const ftpClient = new Client()
+  const port = sshConfig.Port
   const key = fs.readFileSync(path.resolve(os.homedir(), '.ssh/id_rsa'))
   const spinner = ora('Connecting')
   try {
     spinner.start()
     await ftpClient.connect({
-      host: sshConfig['HostName'] as string,
-      port: port ? parseInt(port as string) : 22,
-      username: sshConfig['User'] as string,
+      host: sshConfig.HostName as string,
+      port: port ? Number.parseInt(port as string) : 22,
+      username: sshConfig.User as string,
       passphrase: answer.password,
       privateKey: key,
     })
     releaseConfig.fileMap.sort((it1, it2) => (it1.order ?? 0) - (it2.order ?? 0))
     // upload files
-    for (let item of releaseConfig.fileMap) {
+    for (const item of releaseConfig.fileMap) {
       if (typeof item.src == 'string') {
         if (item.remoteCopy) {
-          await checkParentDir(ftpClient, item.dest, dir => {
+          await checkParentDir(ftpClient, item.dest, (dir) => {
             spinner.warn(`Create Dir: ${dir}`)
           })
-          let destExists = await ftpClient.exists(item.dest)
+          const destExists = await ftpClient.exists(item.dest)
           if (destExists) {
             spinner.warn(`Delete exists file:${item.dest}`)
             await ftpClient.delete(item.dest)
           }
           spinner.info(`Copying File: ${item.src} -> ${item.dest}`)
           await ftpClient.rcopy(item.src, item.dest)
-        } else {
+        }
+        else {
           const localFile = path.resolve(process.cwd(), item.src as string)
           if (!item.remoteCopy && !fs.existsSync(localFile)) {
             spinner.warn(`Skip not exists file:${localFile}`)
@@ -66,19 +67,20 @@ async function runSSH(sshConfig: Record<string, string | string[]>, releaseConfi
           if (fs.lstatSync(localFile).isDirectory()) {
             spinner.info(`Uploading Dir: ${localFile} -> ${item.dest}`)
             await ftpClient.uploadDir(localFile, item.dest, {
-              filter: (filePath: string, isDirectory: boolean):boolean => {
+              filter: (filePath: string, isDirectory: boolean): boolean => {
                 if (item.ignorePattern && !isDirectory) {
-                  let fileName = path.basename(filePath)
+                  const fileName = path.basename(filePath)
                   if (minimatch(fileName, item.ignorePattern)) {
                     spinner.warn(`Skip file:${filePath}`)
                     return false
                   }
                 }
-                return true;
+                return true
               },
             })
-          } else {
-            await checkParentDir(ftpClient, item.dest, dir => {
+          }
+          else {
+            await checkParentDir(ftpClient, item.dest, (dir) => {
               spinner.succeed(`Create Dir: ${dir}`)
             })
 
@@ -86,13 +88,15 @@ async function runSSH(sshConfig: Record<string, string | string[]>, releaseConfi
             await ftpClient.put(localFile, item.dest)
           }
         }
-      } else {
+      }
+      else {
         await ftpClient.put(Buffer.from(JSON.stringify(item.src), 'utf-8'), item.dest)
       }
     }
     spinner.succeed('Files uploaded!')
     await ftpClient.end()
-  } catch (e) {
+  }
+  catch (e) {
     spinner.fail(`Connection error:${e}`)
     await ftpClient.end()
   }
@@ -104,13 +108,13 @@ export async function ftpUpload(releaseFile: string = 'release.json') {
   const packageVersion = Utils.getPackageVersion()
   consola.info('Package Version:', packageVersion)
 
-  let releaseJson = fs.readFileSync(releaseJsonFilePath).toString().replaceAll('${version}', packageVersion)
+  const releaseJson = fs.readFileSync(releaseJsonFilePath).toString().replaceAll('${version}', packageVersion)
   const releaseConfig = JSON.parse(releaseJson) as ReleaseConfig
   const sshConfigFile = path.resolve(os.homedir(), '.ssh/config')
   consola.info('SSH Config File Path:', sshConfigFile)
   const sshConfigs = SSHConfig.parse(fs.readFileSync(sshConfigFile).toString())
-  for (let host of releaseConfig.ftpConfig.host) {
-    let sshConfig = sshConfigs.compute(host)
+  for (const host of releaseConfig.ftpConfig.host) {
+    const sshConfig = sshConfigs.compute(host)
     if (!sshConfig) {
       consola.error(`SSH config ${releaseConfig.ftpConfig.host} not found`)
       return