├── mini-react.txt
├── README.md
└── src
    ├── core
        ├── commands
        │   ├── varbook
        │   │   ├── hooks
        │   │   │   ├── character
        │   │   │   │   ├── base64.ts
        │   │   │   │   └── standard.ts
        │   │   │   └── api
        │   │   │   │   ├── rest
        │   │   │   │       └── translate.ts
        │   │   │   │   └── index.ts
        │   │   ├── varbookCommand.ts
        │   │   └── VarbookBox.vue
        │   ├── relax
        │   │   ├── ikun
        │   │   │   ├── ikun.mp4
        │   │   │   ├── ikunCommand.ts
        │   │   │   ├── IkunBox.vue
        │   │   │   └── charVideo.js
        │   │   ├── music
        │   │   │   ├── musicApi.ts
        │   │   │   ├── musicCommand.ts
        │   │   │   └── MusicBox.vue
        │   │   ├── ikuntest
        │   │   │   ├── IkunTestBox.vue
        │   │   │   └── ikuntestCommand.ts
        │   │   └── moyu
        │   │   │   ├── moyuCommand.ts
        │   │   │   └── MoYuBox.vue
        │   ├── user
        │   │   ├── userConstant.ts
        │   │   ├── type.d.ts
        │   │   ├── subCommands
        │   │   │   ├── logoutCommand.ts
        │   │   │   ├── loginCommand.ts
        │   │   │   └── registerCommand.ts
        │   │   ├── userApi.ts
        │   │   ├── userStore.ts
        │   │   └── userCommands.ts
        │   ├── hot
        │   │   ├── hotApi.ts
        │   │   ├── hotCommand.ts
        │   │   └── HotBox.vue
        │   ├── todo
        │   │   ├── type.d.ts
        │   │   ├── subCommands
        │   │   │   └── addCommand.ts
        │   │   ├── todoCommand.ts
        │   │   ├── TodoBox.vue
        │   │   └── todoStore.ts
        │   ├── fanyi
        │   │   ├── fanYiApi.ts
        │   │   ├── FanYiBox.vue
        │   │   └── fanyiCommand.ts
        │   ├── terminal
        │   │   ├── clearCommand.ts
        │   │   ├── config
        │   │   │   ├── resetCommand.ts
        │   │   │   ├── welcomeCommand.ts
        │   │   │   ├── hintCommand.ts
        │   │   │   ├── backgroundCommand.ts
        │   │   │   └── terminalConfigStore.ts
        │   │   ├── info
        │   │   │   ├── InfoBox.vue
        │   │   │   └── infoCommand.ts
        │   │   ├── shortcut
        │   │   │   ├── ShortcutBox.vue
        │   │   │   └── shortcutCommand.ts
        │   │   ├── historyCommand.ts
        │   │   └── help
        │   │   │   ├── HelpBox.vue
        │   │   │   ├── helpCommand.ts
        │   │   │   ├── CommandHelpBox.vue
        │   │   │   └── helpUtils.ts
        │   ├── space
        │   │   ├── pwdCommand.ts
        │   │   ├── cdCommand.ts
        │   │   ├── spaceCommands.ts
        │   │   ├── mkdirCommand.ts
        │   │   ├── copyCommand.ts
        │   │   ├── moveCommand.ts
        │   │   ├── listCommand.ts
        │   │   ├── removeCommand.ts
        │   │   ├── addCommand.ts
        │   │   └── spaceStore.ts
        │   ├── dateCommand.ts
        │   ├── ddos
        │   │   ├── DdosBox.vue
        │   │   └── ddosCommand.ts
        │   ├── search
        │   │   ├── bilibili
        │   │   │   ├── BilibiliBox.vue
        │   │   │   └── bilibiliCommand.ts
        │   │   ├── mdnCommand.ts
        │   │   ├── bingCommand.ts
        │   │   ├── zhihuCommand.ts
        │   │   ├── doubanCommand.ts
        │   │   ├── douyinCommand.ts
        │   │   ├── sogouCommand.ts
        │   │   ├── gengCommand.ts
        │   │   ├── githubCommand.ts
        │   │   ├── googleCommand.ts
        │   │   ├── codenavCommand.ts
        │   │   ├── wangyiyunCommand.ts
        │   │   ├── baidudevCommand.ts
        │   │   ├── fsearchCommand.ts
        │   │   ├── duckduckgoCommand.ts
        │   │   ├── baiduCommand.ts
        │   │   └── searchCommands.ts
        │   ├── timing
        │   │   ├── timingCommand.ts
        │   │   └── TimingBox.vue
        │   ├── gotoCommand.ts
        │   └── pingCommand.ts
        ├── command.d.ts
        ├── commandRegister.ts
        └── commandExecutor.ts
    ├── App.vue
    ├── plugins
        ├── myDayjs.ts
        └── myAxios.ts
    ├── env.d.ts
    ├── configs
        └── routes.ts
    ├── utils
        └── smartText.ts
    ├── main.ts
    ├── pages
        ├── IndexPage.vue
        └── old
        │   └── XTermPage.vue
    └── components
        └── yu-terminal
            ├── ContentOutput.vue
            ├── history.ts
            ├── hint.ts
            ├── type.d.ts
            ├── shortcuts.ts
            └── YuTerminal.vue


/mini-react.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # mini-react
2 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/hooks/character/base64.ts:
--------------------------------------------------------------------------------
1 | export const enBase64 = (oldVal: string): string => btoa(encodeURI(oldVal));
2 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikun/ikun.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/limingpu123456/mini-react/HEAD/src/core/commands/relax/ikun/ikun.mp4


--------------------------------------------------------------------------------
/src/core/commands/user/userConstant.ts:
--------------------------------------------------------------------------------
1 | import UserType = User.UserType;
2 | 
3 | /**
4 |  * 本地用户
5 |  */
6 | export const LOCAL_USER: UserType = {
7 |   username: "local",
8 | };
9 | 


--------------------------------------------------------------------------------
/src/App.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <router-view />
 3 | </template>
 4 | 
 5 | <script setup lang="ts"></script>
 6 | 
 7 | <style>
 8 | body {
 9 |   margin: 0;
10 | }
11 | </style>
12 | 


--------------------------------------------------------------------------------
/src/core/commands/hot/hotApi.ts:
--------------------------------------------------------------------------------
1 | import myAxios from "../../../plugins/myAxios";
2 | 
3 | /**
4 |  * 获取音乐热榜
5 |  */
6 | export const listHotMusics = async () => {
7 |   return await myAxios.post("/music/list/hot", {});
8 | };
9 | 


--------------------------------------------------------------------------------
/src/core/commands/todo/type.d.ts:
--------------------------------------------------------------------------------
 1 | declare namespace Todo {
 2 |   /**
 3 |    * 任务类型
 4 |    */
 5 |   interface TaskType {
 6 |     name: string;
 7 |     isFinished: boolean;
 8 |     createTime: date;
 9 |     finishTime?: date;
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/core/commands/user/type.d.ts:
--------------------------------------------------------------------------------
 1 | declare namespace User {
 2 |   /**
 3 |    * 用户类型
 4 |    */
 5 |   interface UserType {
 6 |     username: string;
 7 |     email?: string;
 8 |     createTime?: date;
 9 |     updateTime?: date;
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/plugins/myDayjs.ts:
--------------------------------------------------------------------------------
 1 | import dayjs from "dayjs";
 2 | import "dayjs/locale/zh-cn";
 3 | import Duration from "dayjs/plugin/duration";
 4 | 
 5 | // 全局设置为中文
 6 | dayjs.locale("zh-cn");
 7 | dayjs.extend(Duration);
 8 | 
 9 | export default dayjs;
10 | 


--------------------------------------------------------------------------------
/src/env.d.ts:
--------------------------------------------------------------------------------
1 | /// <reference types="vite/client" />
2 | 
3 | declare module '*.vue' {
4 |   import type { DefineComponent } from 'vue'
5 |   // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types
6 |   const component: DefineComponent<{}, {}, any>
7 |   export default component
8 | }
9 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/music/musicApi.ts:
--------------------------------------------------------------------------------
 1 | import myAxios from "../../../../plugins/myAxios";
 2 | 
 3 | /**
 4 |  * 搜索单条音乐
 5 |  * @param keywords
 6 |  */
 7 | export const getSingleMusic = async (keywords: string) => {
 8 |   if (!keywords) {
 9 |     return null;
10 |   }
11 |   return await myAxios.post("/music/get", { keywords });
12 | };
13 | 


--------------------------------------------------------------------------------
/src/configs/routes.ts:
--------------------------------------------------------------------------------
 1 | import { RouteRecordRaw } from "vue-router";
 2 | import IndexPage from "../pages/IndexPage.vue";
 3 | import XTermPage from "../pages/old/XTermPage.vue";
 4 | 
 5 | const routes: RouteRecordRaw[] = [
 6 |   { path: "/", component: IndexPage },
 7 |   { path: "/old/xterm", component: XTermPage },
 8 | ];
 9 | 
10 | export default routes;
11 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikuntest/IkunTestBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="ikun-test-box" style="margin: 8px 0">
 3 |     <iframe src="https://www.ikuntest.com" />
 4 |   </div>
 5 | </template>
 6 | 
 7 | <script setup lang="ts"></script>
 8 | 
 9 | <style scoped>
10 | .ikun-test-box > iframe {
11 |   border: none;
12 |   height: 640px;
13 |   width: 100%;
14 |   max-width: 420px;
15 | }
16 | </style>
17 | 


--------------------------------------------------------------------------------
/src/core/commands/fanyi/fanYiApi.ts:
--------------------------------------------------------------------------------
 1 | import myAxios from "../../../plugins/myAxios";
 2 | 
 3 | /**
 4 |  * 翻译文本
 5 |  * @param keywords
 6 |  * @param config
 7 |  */
 8 | export const translate = async (
 9 |   keywords: string,
10 |   config: Record<string, string>
11 | ) => {
12 |   if (!keywords) {
13 |     return null;
14 |   }
15 |   return await myAxios.post("/fanyi/translate", { keywords, config });
16 | };
17 | 


--------------------------------------------------------------------------------
/src/core/commands/fanyi/FanYiBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <iframe src="https://fanyi.baidu.com/" />
 4 |   </div>
 5 | </template>
 6 | 
 7 | <script setup lang="ts">
 8 | import { toRefs } from "vue";
 9 | 
10 | // interface FanYiBoxProps {
11 | //
12 | // }
13 | //
14 | // const props = withDefaults(defineProps<FanYiBoxProps>(), {});
15 | // const {} = toRefs(props);
16 | </script>
17 | 
18 | <style scoped></style>
19 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/hooks/api/rest/translate.ts:
--------------------------------------------------------------------------------
 1 | import { translate } from "../index";
 2 | import { enBase64 } from "../../character/base64";
 3 | 
 4 | const { get } = translate;
 5 | 
 6 | const getNamedVariables = async (searchText: string) => {
 7 |   const s = enBase64(searchText);
 8 |   const params = {
 9 |     s,
10 |   };
11 |   const res = await get("", { params });
12 |   return res;
13 | };
14 | 
15 | export { getNamedVariables };
16 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/clearCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 清屏命令
 5 |  * @author yupi
 6 |  */
 7 | const clearCommand: CommandType = {
 8 |   func: "clear",
 9 |   name: "清屏",
10 |   alias: ["cl"],
11 |   options: [],
12 |   action(options, terminal): void {
13 |     // 延时，把当前这条 clear 命令也清掉
14 |     setTimeout(() => {
15 |       terminal.clear();
16 |     }, 100);
17 |   },
18 | };
19 | 
20 | export default clearCommand;
21 | 


--------------------------------------------------------------------------------
/src/core/commands/space/pwdCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { useSpaceStore } from "./spaceStore";
 3 | 
 4 | /**
 5 |  * 显示当前所在目录
 6 |  */
 7 | const pwdCommand: CommandType = {
 8 |   func: "pwd",
 9 |   name: "显示当前空间位置",
10 |   options: [],
11 |   action(options, terminal): void {
12 |     const spaceStore = useSpaceStore();
13 |     const output = `当前目录：${spaceStore.currentDir}`;
14 |     terminal.writeTextResult(output);
15 |   },
16 | };
17 | 
18 | export default pwdCommand;
19 | 


--------------------------------------------------------------------------------
/src/core/commands/dateCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../command";
 2 | import myDayjs from "../../plugins/myDayjs";
 3 | 
 4 | /**
 5 |  * 日期命令
 6 |  * @author yupi
 7 |  */
 8 | const dateCommand: CommandType = {
 9 |   func: "date",
10 |   name: "日期",
11 |   options: [],
12 |   action(options, terminal): void {
13 |     const dateStr = myDayjs().format("YYYY-MM-DD HH:mm:ss");
14 |     const output = `当前时间：${dateStr}`;
15 |     terminal.writeTextResult(output);
16 |   },
17 | };
18 | 
19 | export default dateCommand;
20 | 


--------------------------------------------------------------------------------
/src/core/commands/ddos/DdosBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div>珍惜生活，远离 DDOS！</div>
 4 |     <div>
 5 |       网络安全学习网站：
 6 |       <a href="https://ceshiya.vercel.app/" target="_blank">
 7 |         https://ceshiya.vercel.app/
 8 |       </a>
 9 |     </div>
10 |     <img
11 |       width="200"
12 |       style="margin: 8px 0"
13 |       src="https://s1.ax1x.com/2022/07/19/j76SQU.png"
14 |       alt="做个好人"
15 |     />
16 |   </div>
17 | </template>
18 | 
19 | <script setup lang="ts"></script>
20 | 
21 | <style scoped></style>
22 | 


--------------------------------------------------------------------------------
/src/utils/smartText.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * 匹配网址正则
 3 |  */
 4 | const URL_REG =
 5 |   /(((https?:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)/;
 6 | 
 7 | /**
 8 |  * 识别文本中的超链接
 9 |  * @param text
10 |  */
11 | const smartText = (text?: string) => {
12 |   if (!text) {
13 |     return text;
14 |   }
15 |   const reg = new RegExp(URL_REG, "gi");
16 |   return text.replaceAll(reg, "<a href='$1' target='_blank'>$1</a>");
17 | };
18 | 
19 | export default smartText;
20 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/config/resetCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { useTerminalConfigStore } from "./terminalConfigStore";
 3 | 
 4 | /**
 5 |  * 重置配置
 6 |  * @author yupi
 7 |  */
 8 | const resetCommand: CommandType = {
 9 |   func: "reset",
10 |   name: "重置终端配置",
11 |   alias: [],
12 |   options: [],
13 |   action(options, terminal): void {
14 |     const { reset } = useTerminalConfigStore();
15 |     reset();
16 |     terminal.writeTextSuccessResult("已重置终端配置");
17 |   },
18 | };
19 | 
20 | export default resetCommand;
21 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
 1 | import { createApp } from "vue";
 2 | import App from "./App.vue";
 3 | import * as VueRouter from "vue-router";
 4 | import routes from "./configs/routes";
 5 | import { createPinia } from "pinia";
 6 | import piniaPluginPersistedstate from "pinia-plugin-persistedstate";
 7 | 
 8 | const app = createApp(App);
 9 | 
10 | // 路由
11 | const router = VueRouter.createRouter({
12 |   history: VueRouter.createWebHashHistory(),
13 |   routes,
14 | });
15 | app.use(router);
16 | 
17 | // 状态管理
18 | const pinia = createPinia();
19 | pinia.use(piniaPluginPersistedstate);
20 | app.use(pinia);
21 | 
22 | app.mount("#app");
23 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/info/InfoBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>关于本站：YuIndex 极客范儿的浏览器主页</div>
 3 |   <div>
 4 |     <a href="https://github.com/liyupi/yuindex" target="_blank">
 5 |       代码开源，欢迎 star 和贡献~
 6 |     </a>
 7 |   </div>
 8 |   <div></div>
 9 |   <div>
10 |     作者：
11 |     <a href="https://docs.qq.com/doc/DUFFRVWladXVjeUxW" target="_blank">
12 |       程序员鱼皮
13 |     </a>
14 |   </div>
15 | </template>
16 | 
17 | <script setup lang="ts">
18 | interface InfoBoxProps {
19 |   seconds: string;
20 | }
21 | 
22 | const props = withDefaults(defineProps<InfoBoxProps>(), {});
23 | </script>
24 | 
25 | <style scoped></style>
26 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/shortcut/ShortcutBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div>快捷键：</div>
 4 |     <div v-for="(shortcut, index) in shortcutList" :key="index">
 5 |       <a-row v-if="shortcut.desc" :gutter="16">
 6 |         <a-col :span="4">{{ shortcut.keyDesc ?? shortcut.code }}</a-col>
 7 |         <a-col :span="4">{{ shortcut.desc }}</a-col>
 8 |       </a-row>
 9 |     </div>
10 |   </div>
11 | </template>
12 | 
13 | <script setup lang="ts">
14 | import { onMounted } from "vue";
15 | import { shortcutList } from "../../../../components/yu-terminal/shortcuts";
16 | 
17 | onMounted(() => {});
18 | </script>
19 | 
20 | <style scoped></style>
21 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/historyCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 查看历史命令
 5 |  * @author yupi
 6 |  */
 7 | const historyCommand: CommandType = {
 8 |   func: "history",
 9 |   name: "查看执行历史",
10 |   alias: ["h"],
11 |   options: [],
12 |   collapsible: true,
13 |   action(options, terminal): void {
14 |     const commandOutputTypes = terminal.listCommandHistory();
15 |     // terminal.writeTextResult(`⭐️ 输入 ![序号] 可以快速执行某条历史命令`);
16 |     commandOutputTypes.forEach((command, index) => {
17 |       terminal.writeTextResult(`${index + 1} ${command.text}`);
18 |     });
19 |   },
20 | };
21 | 
22 | export default historyCommand;
23 | 


--------------------------------------------------------------------------------
/src/core/commands/search/bilibili/BilibiliBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <iframe
 4 |       frameborder="no"
 5 |       marginwidth="0"
 6 |       marginheight="0"
 7 |       :src="videoPath"
 8 |     />
 9 |   </div>
10 | </template>
11 | 
12 | <script setup lang="ts">
13 | import { computed, toRefs } from "vue";
14 | 
15 | interface MusicBoxProps {
16 |   bvid: string;
17 | }
18 | 
19 | const props = withDefaults(defineProps<MusicBoxProps>(), {});
20 | const { bvid } = toRefs(props);
21 | 
22 | const videoPath = computed(() => {
23 |   return `https://player.bilibili.com/player.html?bvid=${bvid.value}`;
24 | });
25 | </script>
26 | 
27 | <style scoped></style>
28 | 


--------------------------------------------------------------------------------
/src/core/commands/ddos/ddosCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * DDOS 命令（整活）
 7 |  * @author yupi
 8 |  */
 9 | const ddosCommand: CommandType = {
10 |   func: "ddos",
11 |   name: "ddos",
12 |   desc: "发起网络攻击，慎用！",
13 |   options: [],
14 |   action(options, terminal) {
15 |     const output: ComponentOutputType = {
16 |       type: "component",
17 |       component: defineAsyncComponent(() => import("./DdosBox.vue")),
18 |       props: {},
19 |     };
20 |     terminal.writeResult(output);
21 |   },
22 | };
23 | 
24 | export default ddosCommand;
25 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/moyu/moyuCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 摸鱼命令
 7 |  * @author yupi
 8 |  */
 9 | const moyuCommand: CommandType = {
10 |   func: "moyu",
11 |   name: "摸鱼",
12 |   options: [],
13 |   collapsible: true,
14 |   action(options, terminal) {
15 |     const output: ComponentOutputType = {
16 |       type: "component",
17 |       component: defineAsyncComponent(() => import("./MoYuBox.vue")),
18 |       props: {},
19 |     };
20 |     terminal.writeResult(output);
21 |   },
22 | };
23 | 
24 | export default moyuCommand;
25 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/info/infoCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 查看网站本身信息命令
 7 |  * @author yupi
 8 |  */
 9 | const infoCommand: CommandType = {
10 |   func: "info",
11 |   name: "查看本站信息",
12 |   alias: ["author", "about"],
13 |   options: [],
14 |   action(options, terminal): void {
15 |     const output: ComponentOutputType = {
16 |       type: "component",
17 |       component: defineAsyncComponent(() => import("./InfoBox.vue")),
18 |     };
19 |     terminal.writeResult(output);
20 |   },
21 | };
22 | 
23 | export default infoCommand;
24 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikun/ikunCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * ikun 命令（整活）
 7 |  * @author yupi
 8 |  */
 9 | const ikunCommand: CommandType = {
10 |   func: "ikun",
11 |   name: "ikun",
12 |   options: [],
13 |   collapsible: true,
14 |   action(options, terminal) {
15 |     const output: ComponentOutputType = {
16 |       type: "component",
17 |       component: defineAsyncComponent(() => import("./IkunBox.vue")),
18 |       props: {},
19 |     };
20 |     terminal.writeResult(output);
21 |   },
22 | };
23 | 
24 | export default ikunCommand;
25 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/help/HelpBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div>
 4 |       ⭐️ 使用 [help 命令英文名] 可以查询某命令的具体用法，如：help search
 5 |     </div>
 6 |     <div>命令列表：</div>
 7 |     <div v-for="(command, index) in commandList" :key="index">
 8 |       <a-row :gutter="16">
 9 |         <a-col :span="4">{{ command.func }}</a-col>
10 |         <a-col :span="4">{{ command.name }}</a-col>
11 |         <a-col>{{ command.desc }}</a-col>
12 |       </a-row>
13 |     </div>
14 |   </div>
15 | </template>
16 | 
17 | <script setup lang="ts">
18 | import { onMounted } from "vue";
19 | import { commandList } from "../../../commandRegister";
20 | 
21 | onMounted(() => {});
22 | </script>
23 | 
24 | <style scoped></style>
25 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikuntest/ikuntestCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * ikun 测试（整活）
 7 |  * @author yupi
 8 |  */
 9 | const ikuntestCommand: CommandType = {
10 |   func: "ikuntest",
11 |   name: "ikun测试",
12 |   desc: "测试一下你是真 ikun 还是小黑子",
13 |   options: [],
14 |   collapsible: true,
15 |   action(options, terminal) {
16 |     const output: ComponentOutputType = {
17 |       type: "component",
18 |       component: defineAsyncComponent(() => import("./IkunTestBox.vue")),
19 |       props: {},
20 |     };
21 |     terminal.writeResult(output);
22 |   },
23 | };
24 | 
25 | export default ikuntestCommand;
26 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/config/welcomeCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { useTerminalConfigStore } from "./terminalConfigStore";
 3 | 
 4 | /**
 5 |  * 自定义终端欢迎语
 6 |  * @author yupi
 7 |  */
 8 | const welcomeCommand: CommandType = {
 9 |   func: "welcome",
10 |   name: "自定义终端欢迎语",
11 |   alias: [],
12 |   params: [
13 |     {
14 |       key: "texts",
15 |       desc: "终端提示文本（支持多个值，不填则无欢迎语）",
16 |       required: false,
17 |     },
18 |   ],
19 |   options: [],
20 |   async action(options, terminal) {
21 |     const { _ } = options;
22 |     let welcomeTexts = _;
23 |     const { setWelcomeTexts } = useTerminalConfigStore();
24 |     setWelcomeTexts(welcomeTexts);
25 |   },
26 | };
27 | 
28 | export default welcomeCommand;
29 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/shortcut/shortcutCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 快捷键命令
 7 |  * @author yupi
 8 |  */
 9 | const shortcutCommand: CommandType = {
10 |   func: "shortcut",
11 |   name: "快捷键",
12 |   desc: "查看快捷键",
13 |   alias: [],
14 |   params: [],
15 |   options: [],
16 |   collapsible: true,
17 |   action(options, terminal): void {
18 |     const output: ComponentOutputType = {
19 |       type: "component",
20 |       component: defineAsyncComponent(() => import("./ShortcutBox.vue")),
21 |     };
22 |     terminal.writeResult(output);
23 |   },
24 | };
25 | 
26 | export default shortcutCommand;
27 | 


--------------------------------------------------------------------------------
/src/core/commands/hot/hotCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 热榜命令
 7 |  * @author yupi
 8 |  */
 9 | const hotCommand: CommandType = {
10 |   func: "hot",
11 |   name: "热榜",
12 |   alias: [],
13 |   params: [
14 |     {
15 |       key: "热榜类别",
16 |       desc: "要查询的热榜",
17 |       required: false,
18 |     },
19 |   ],
20 |   options: [],
21 |   collapsible: true,
22 |   async action(options, terminal) {
23 |     const output: ComponentOutputType = {
24 |       type: "component",
25 |       component: defineAsyncComponent(() => import("./HotBox.vue")),
26 |       props: {},
27 |     };
28 |     terminal.writeResult(output);
29 |   },
30 | };
31 | 
32 | export default hotCommand;
33 | 


--------------------------------------------------------------------------------
/src/core/commands/user/subCommands/logoutCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { userLogin, userLogout, userRegister } from "../userApi";
 3 | import { useUserStore } from "../userStore";
 4 | import { LOCAL_USER } from "../userConstant";
 5 | 
 6 | /**
 7 |  * 用户注销命令
 8 |  * @author yupi
 9 |  */
10 | const logoutCommand: CommandType = {
11 |   func: "logout",
12 |   name: "用户注销",
13 |   options: [],
14 |   async action(options, terminal) {
15 |     const res: any = await userLogout();
16 |     const { setLoginUser } = useUserStore();
17 |     if (res?.code === 0) {
18 |       setLoginUser(LOCAL_USER);
19 |       terminal.writeTextSuccessResult("已退出登录");
20 |     } else {
21 |       terminal.writeTextErrorResult(res?.message ?? "注销失败");
22 |     }
23 |   },
24 | };
25 | 
26 | export default logoutCommand;
27 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/hooks/api/index.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  *
 3 |  * 为了您的隐私安全，如果您是第三方调用可能会记录下您的调用信息
 4 |  * 开放API不代表您可以滥用，请您保持尊重，请勿基于此API进行二次开发
 5 |  *
 6 |  *
 7 |  * For your privacy and security, if you are a third party caller, your call letter may be recorded.
 8 |  * Open API does not mean you can abuse it, please keep it respectful and do not use it for secondary development.
 9 |  *
10 |  */
11 | 
12 | import axios from "axios";
13 | 
14 | const ROOT_URL = "https://api-varbook.uiuing.com";
15 | 
16 | const translate = axios.create({
17 |   baseURL: `${ROOT_URL}/translate`,
18 | });
19 | 
20 | translate.interceptors.response.use((response) => {
21 |   if (response.status === 200) {
22 |     const { data } = response;
23 |     return Promise.resolve(data);
24 |   }
25 |   return Promise.reject(response);
26 | });
27 | 
28 | export { translate };
29 | 


--------------------------------------------------------------------------------
/src/core/commands/hot/HotBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div v-for="(song, index) in songList" :key="index">
 4 |       <a :href="`https://music.163.com/#/song?id=${song?.id}`" target="_blank">
 5 |         {{ song?.al?.name }}
 6 |       </a>
 7 |       <img :src="song?.al?.picUrl" height="25" :alt="song?.al?.name" />
 8 |     </div>
 9 |   </div>
10 | </template>
11 | 
12 | <script setup lang="ts">
13 | import { onMounted, ref } from "vue";
14 | import { listHotMusics } from "./hotApi";
15 | import { message } from "ant-design-vue";
16 | 
17 | const songList = ref([] as any[]);
18 | 
19 | onMounted(async () => {
20 |   const res: any = await listHotMusics();
21 |   if (res?.code === 0) {
22 |     const songs = res.data;
23 |     songList.value = songs.slice(0, 10);
24 |   } else {
25 |     message.error("加载失败");
26 |   }
27 | });
28 | </script>
29 | 
30 | <style scoped></style>
31 | 


--------------------------------------------------------------------------------
/src/core/commands/search/mdnCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | const mdnCommand: CommandType = {
 4 |   func: "mdn",
 5 |   name: "MozillaMDN",
 6 |   alias: ["mdn", "mozillamdn"],
 7 |   params: [
 8 |     {
 9 |       key: "word",
10 |       desc: "搜索内容",
11 |       required: true,
12 |     },
13 |   ],
14 |   options: [
15 |     {
16 |       key: "self",
17 |       desc: "是否当前页面打开",
18 |       alias: ["s"],
19 |       type: "boolean",
20 |       defaultValue: false,
21 |     },
22 |   ],
23 |   action(options, terminal) {
24 |     const { _, self } = options;
25 |     const word = _.length > 0 ? _[0] : "";
26 |     const targetLink = `https://developer.mozilla.org/zh-CN/search?q=${word}`;
27 |     if (self) {
28 |       window.location.href = targetLink;
29 |     } else {
30 |       window.open(targetLink);
31 |     }
32 |   },
33 | };
34 | 
35 | export default mdnCommand;
36 | 


--------------------------------------------------------------------------------
/src/core/commands/search/bingCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 必应搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const bingCommand: CommandType = {
 8 |   func: "bing",
 9 |   name: "必应搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.bing.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default bingCommand;
40 | 


--------------------------------------------------------------------------------
/src/pages/IndexPage.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <yu-terminal
 3 |     ref="terminalRef"
 4 |     :user="loginUser"
 5 |     full-screen
 6 |     :on-submit-command="onSubmitCommand"
 7 |   />
 8 | </template>
 9 | 
10 | <script setup lang="ts">
11 | import { doCommandExecute } from "../core/commandExecutor";
12 | import { onMounted, ref } from "vue";
13 | import { useUserStore } from "../core/commands/user/userStore";
14 | import { storeToRefs } from "pinia";
15 | 
16 | const terminalRef = ref();
17 | 
18 | const onSubmitCommand = async (inputText: string) => {
19 |   if (!inputText) {
20 |     return;
21 |   }
22 |   const terminal = terminalRef.value.terminal;
23 |   await doCommandExecute(inputText, terminal);
24 | };
25 | 
26 | const userStore = useUserStore();
27 | const { loginUser } = storeToRefs(userStore);
28 | 
29 | onMounted(() => {
30 |   userStore.getAndSetLoginUser();
31 | });
32 | </script>
33 | 
34 | <style></style>
35 | 


--------------------------------------------------------------------------------
/src/core/commands/search/zhihuCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 知乎搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const zhihuCommand: CommandType = {
 8 |   func: "zhihu",
 9 |   name: "知乎搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.zhihu.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default zhihuCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/doubanCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 豆瓣搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const doubanCommand: CommandType = {
 8 |   func: "douban",
 9 |   name: "豆瓣搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.douban.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default doubanCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/douyinCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 抖音搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const douyinCommand: CommandType = {
 8 |   func: "douyin",
 9 |   name: "抖音搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.douyin.com/search/${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default douyinCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/space/cdCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { useSpaceStore } from "./spaceStore";
 3 | 
 4 | /**
 5 |  * 切换目录
 6 |  */
 7 | const cdCommand: CommandType = {
 8 |   func: "cd",
 9 |   name: "切换空间目录",
10 |   params: [
11 |     {
12 |       key: "dir",
13 |       desc: "目标目录",
14 |       required: true,
15 |     },
16 |   ],
17 |   options: [],
18 |   action(options, terminal): void {
19 |     const { _ } = options;
20 |     if (_.length < 1) {
21 |       terminal.writeTextErrorResult("参数不足");
22 |       return;
23 |     }
24 |     const targetDir = _[0];
25 |     const spaceStore = useSpaceStore();
26 |     const result = spaceStore.updateCurrentDir(targetDir);
27 |     if (result) {
28 |       terminal.writeTextResult(`已切换至目录：${spaceStore.currentDir}`);
29 |     } else {
30 |       terminal.writeTextErrorResult("切换目录失败");
31 |     }
32 |   },
33 | };
34 | 
35 | export default cdCommand;
36 | 


--------------------------------------------------------------------------------
/src/core/commands/search/sogouCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 搜狗搜索命令
 5 |  * @author Edmon-Leo
 6 |  */
 7 | const sogouCommand: CommandType = {
 8 |   func: "sogou",
 9 |   name: "搜狗搜索",
10 |   alias: ["sg"],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.sogou.com/web?query=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default sogouCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/gengCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 查梗（小鸡词典）命令
 5 |  * @author yupi
 6 |  */
 7 | const gengCommand: CommandType = {
 8 |   func: "geng",
 9 |   name: "梗搜索",
10 |   alias: ["xiaoji"],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://jikipedia.com/search?phrase=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default gengCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/githubCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * GitHub 搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const githubCommand: CommandType = {
 8 |   func: "github",
 9 |   name: "GitHub 搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://github.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default githubCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/googleCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * Google 搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const googleCommand: CommandType = {
 8 |   func: "google",
 9 |   name: "Google 搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.google.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default googleCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/codenavCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 编程导航搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const codenavCommand: CommandType = {
 8 |   func: "codenav",
 9 |   name: "编程资源搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://www.code-nav.cn/resources?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default codenavCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/wangyiyunCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 网易云搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const wangyiyunCommand: CommandType = {
 8 |   func: "wangyiyun",
 9 |   name: "网易云搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://music.163.com/#/search/m/?s=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default wangyiyunCommand;
40 | 


--------------------------------------------------------------------------------
/src/plugins/myAxios.ts:
--------------------------------------------------------------------------------
 1 | import axios from "axios";
 2 | 
 3 | // 自定义 axios 实例
 4 | const myAxios = axios.create({
 5 |   baseURL:
 6 |     // @ts-ignore
 7 |     process.env.NODE_ENV === "production"
 8 |       ? "https://yuindex-server-974538-1256524210.ap-shanghai.run.tcloudbase.com/api"
 9 |       : "http://localhost:7345/api",
10 | });
11 | 
12 | myAxios.defaults.withCredentials = true;
13 | 
14 | // 添加请求拦截器
15 | myAxios.interceptors.request.use(
16 |   function (config) {
17 |     // 在发送请求之前做些什么
18 |     return config;
19 |   },
20 |   function (error) {
21 |     // 对请求错误做些什么
22 |     return Promise.reject(error);
23 |   }
24 | );
25 | 
26 | // 添加响应拦截器
27 | myAxios.interceptors.response.use(
28 |   function (response) {
29 |     console.log(response);
30 |     // 对响应数据做点什么
31 |     return response.data;
32 |   },
33 |   function (error) {
34 |     // 对响应错误做点什么
35 |     return Promise.reject(error);
36 |   }
37 | );
38 | 
39 | export default myAxios;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/baidudevCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 百度开发者搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const baidudevCommand: CommandType = {
 8 |   func: "baidudev",
 9 |   name: "百度开发者搜索",
10 |   alias: ["dev"],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://kaifa.baidu.com/searchPage?wd=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default baidudevCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/space/spaceCommands.ts:
--------------------------------------------------------------------------------
 1 | import listCommand from "./listCommand";
 2 | import removeCommand from "./removeCommand";
 3 | import addCommand from "./addCommand";
 4 | import mkdirCommand from "./mkdirCommand";
 5 | import pwdCommand from "./pwdCommand";
 6 | import cdCommand from "./cdCommand";
 7 | import moveCommand from "./moveCommand";
 8 | import copyCommand from "./copyCommand";
 9 | 
10 | /**
11 |  * 空间类型（扁平）
12 |  */
13 | export interface SpaceType {
14 |   [dir: string]: SpaceItemType;
15 | }
16 | 
17 | /**
18 |  * 空间项类型
19 |  */
20 | export interface SpaceItemType {
21 |   // 条目 / 目录名
22 |   name: string;
23 |   link?: string;
24 |   // 所属目录
25 |   dir: string;
26 |   type: "dir" | "link";
27 | }
28 | 
29 | /**
30 |  * 空间命令，类似文件系统 + 收藏夹
31 |  */
32 | export default [
33 |   listCommand,
34 |   removeCommand,
35 |   addCommand,
36 |   mkdirCommand,
37 |   pwdCommand,
38 |   cdCommand,
39 |   moveCommand,
40 |   copyCommand,
41 | ];
42 | 


--------------------------------------------------------------------------------
/src/core/commands/search/fsearchCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * F search 搜索命令
 5 |  * @author Edmon-Leo
 6 |  */
 7 | const fsearchCommand: CommandType = {
 8 |   func: "fsearch",
 9 |   name: "F搜",
10 |   alias: ["fs", "ff", "fsou"],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://fsoufsou.com/search?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default fsearchCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/search/duckduckgoCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * DuckDuckGo 搜索命令
 5 |  * @author Edmon-Leo
 6 |  */
 7 | const duckduckgoCommand: CommandType = {
 8 |   func: "duckduckgo",
 9 |   name: "DuckDuckGo搜索",
10 |   alias: ["ddg", "duck"],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   action(options, terminal) {
28 |     const { _, self } = options;
29 |     const word = _.length > 0 ? _[0] : "";
30 |     const targetLink = `https://duckduckgo.com/?q=${word}`;
31 |     if (self) {
32 |       window.location.href = targetLink;
33 |     } else {
34 |       window.open(targetLink);
35 |     }
36 |   },
37 | };
38 | 
39 | export default duckduckgoCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/config/hintCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { useTerminalConfigStore } from "./terminalConfigStore";
 3 | 
 4 | /**
 5 |  * 提示命令
 6 |  * @author yupi
 7 |  */
 8 | const hintCommand: CommandType = {
 9 |   func: "hint",
10 |   name: "开关提示",
11 |   desc: "开启 / 关闭输入提示",
12 |   params: [
13 |     {
14 |       key: "switch",
15 |       desc: "开关：on 开启, off 关闭",
16 |       defaultValue: "on",
17 |     },
18 |   ],
19 |   options: [],
20 |   async action(options, terminal) {
21 |     const { _ } = options;
22 |     const { setOrToggleShowHint } = useTerminalConfigStore();
23 |     let newHint;
24 |     if (_.length >= 1) {
25 |       if (["on", "off"].includes(_[0])) {
26 |         newHint = _[0];
27 |       }
28 |     }
29 |     const res = setOrToggleShowHint(newHint);
30 |     terminal.writeTextSuccessResult(
31 |       `输入提示已${res ? "开启" : "关闭"}，刷新页面后生效`
32 |     );
33 |   },
34 | };
35 | 
36 | export default hintCommand;
37 | 


--------------------------------------------------------------------------------
/src/core/commands/timing/timingCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 定时命令
 7 |  * @author yupi
 8 |  */
 9 | const timingCommand: CommandType = {
10 |   func: "timing",
11 |   name: "定时器",
12 |   options: [
13 |     {
14 |       key: "seconds",
15 |       desc: "秒数",
16 |       alias: ["s"],
17 |       type: "string",
18 |       required: true,
19 |     },
20 |   ],
21 |   action(options, terminal) {
22 |     const { _, seconds } = options;
23 |     if (!seconds) {
24 |       terminal.writeTextErrorResult("参数不足");
25 |       return;
26 |     }
27 |     const output: ComponentOutputType = {
28 |       type: "component",
29 |       component: defineAsyncComponent(() => import("./TimingBox.vue")),
30 |       props: {
31 |         seconds,
32 |       },
33 |     };
34 |     terminal.writeResult(output);
35 |   },
36 | };
37 | 
38 | export default timingCommand;
39 | 


--------------------------------------------------------------------------------
/src/core/commands/todo/subCommands/addCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { useTodoStore } from "../todoStore";
 3 | import TaskType = Todo.TaskType;
 4 | 
 5 | /**
 6 |  * 添加任务命令
 7 |  * @author yupi
 8 |  */
 9 | const addCommand: CommandType = {
10 |   func: "add",
11 |   name: "添加任务",
12 |   options: [
13 |     {
14 |       key: "name",
15 |       desc: "任务名称",
16 |       alias: ["n"],
17 |       type: "string",
18 |       required: true,
19 |     },
20 |   ],
21 |   action(options, terminal) {
22 |     const { name } = options;
23 |     if (!name) {
24 |       terminal.writeTextErrorResult("请输入任务名称");
25 |       return;
26 |     }
27 |     const { addTask } = useTodoStore();
28 |     const newTask = {
29 |       name,
30 |     } as TaskType;
31 |     const res = addTask(newTask);
32 |     if (res) {
33 |       terminal.writeTextSuccessResult("添加任务成功");
34 |     } else {
35 |       terminal.writeTextErrorResult("操作失败");
36 |     }
37 |   },
38 | };
39 | 
40 | export default addCommand;
41 | 


--------------------------------------------------------------------------------
/src/core/commands/todo/todoCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | import addCommand from "./subCommands/addCommand";
 5 | 
 6 | /**
 7 |  * 待办事项命令
 8 |  * @author yupi
 9 |  */
10 | const todoCommand: CommandType = {
11 |   func: "todo",
12 |   name: "待办事项",
13 |   desc: "记录和管理任务",
14 |   params: [
15 |     {
16 |       key: "subCommand",
17 |       desc: "子命令",
18 |       required: true,
19 |     },
20 |   ],
21 |   options: [],
22 |   subCommands: {
23 |     add: addCommand,
24 |   },
25 |   collapsible: true,
26 |   action(options, terminal) {
27 |     const { _ } = options;
28 |     if (_.length < 1) {
29 |       const output: ComponentOutputType = {
30 |         type: "component",
31 |         component: defineAsyncComponent(() => import("./TodoBox.vue")),
32 |       };
33 |       terminal.writeResult(output);
34 |       return;
35 |     }
36 |   },
37 | };
38 | 
39 | export default todoCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/music/musicCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | /**
 6 |  * 音乐命令
 7 |  * @author yupi
 8 |  */
 9 | const musicCommand: CommandType = {
10 |   func: "music",
11 |   name: "音乐",
12 |   desc: "在线听音乐",
13 |   params: [
14 |     {
15 |       key: "name",
16 |       desc: "音乐名称",
17 |       required: true,
18 |     },
19 |   ],
20 |   options: [],
21 |   collapsible: true,
22 |   action(options, terminal) {
23 |     const { _ } = options;
24 |     if (_.length < 1) {
25 |       terminal.writeTextErrorResult("参数不足");
26 |       return;
27 |     }
28 |     const name = _[0];
29 |     const output: ComponentOutputType = {
30 |       type: "component",
31 |       component: defineAsyncComponent(() => import("./MusicBox.vue")),
32 |       props: {
33 |         name,
34 |       },
35 |     };
36 |     terminal.writeResult(output);
37 |   },
38 | };
39 | 
40 | export default musicCommand;
41 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/config/backgroundCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { useTerminalConfigStore } from "./terminalConfigStore";
 3 | import axios from "axios";
 4 | import myAxios from "../../../../plugins/myAxios";
 5 | 
 6 | /**
 7 |  * 切换终端背景
 8 |  * @author yupi
 9 |  */
10 | const backgroundCommand: CommandType = {
11 |   func: "background",
12 |   name: "切换终端背景",
13 |   alias: ["bg"],
14 |   params: [
15 |     {
16 |       key: "url",
17 |       desc: "图片地址（不填则随机）",
18 |       required: false,
19 |     },
20 |   ],
21 |   options: [],
22 |   async action(options, terminal) {
23 |     const { _ } = options;
24 |     let url = _[0];
25 |     if (_.length > 0) {
26 |       url = _[0];
27 |     }
28 |     const { setBackground } = useTerminalConfigStore();
29 |     if (!url) {
30 |       // 随机获取壁纸
31 |       const res = await myAxios.post("/background/get/random");
32 |       setBackground(res.data);
33 |     }
34 |     setBackground(url);
35 |   },
36 | };
37 | 
38 | export default backgroundCommand;
39 | 


--------------------------------------------------------------------------------
/src/core/commands/user/userApi.ts:
--------------------------------------------------------------------------------
 1 | import myAxios from "../../../plugins/myAxios";
 2 | 
 3 | /**
 4 |  * 用户登录
 5 |  * @param username
 6 |  * @param password
 7 |  */
 8 | export const userLogin = async (username: string, password: string) => {
 9 |   if (!username || !password) {
10 |     return null;
11 |   }
12 |   return await myAxios.post("/user/login", { username, password });
13 | };
14 | 
15 | /**
16 |  * 用户注销
17 |  */
18 | export const userLogout = async () => {
19 |   return await myAxios.post("/user/logout");
20 | };
21 | 
22 | /**
23 |  * 用户注册
24 |  * @param username
25 |  * @param password
26 |  * @param email
27 |  */
28 | export const userRegister = async (
29 |   username: string,
30 |   password: string,
31 |   email: string
32 | ) => {
33 |   if (!username || !password || !email) {
34 |     return null;
35 |   }
36 |   return await myAxios.post("/user/register", { username, password, email });
37 | };
38 | 
39 | /**
40 |  * 获取当前登录用户
41 |  */
42 | export const getLoginUser = async () => {
43 |   return await myAxios.post("/user/current");
44 | };
45 | 


--------------------------------------------------------------------------------
/src/core/commands/space/mkdirCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { SpaceItemType } from "./spaceCommands";
 3 | import { useSpaceStore } from "./spaceStore";
 4 | 
 5 | /**
 6 |  * 创建目录
 7 |  */
 8 | const mkdirCommand: CommandType = {
 9 |   func: "mkdir",
10 |   name: "创建空间目录",
11 |   params: [
12 |     {
13 |       key: "dir",
14 |       desc: "新目录路径",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [],
19 |   action(options, terminal): void {
20 |     const { _ } = options;
21 |     if (_.length < 1) {
22 |       terminal.writeTextErrorResult("参数不足");
23 |       return;
24 |     }
25 |     const spaceStore = useSpaceStore();
26 |     const newDir = _[0];
27 |     const item: SpaceItemType = {
28 |       dir: spaceStore.currentDir,
29 |       name: newDir,
30 |       type: "dir",
31 |     };
32 |     const result = spaceStore.addItem(item);
33 |     if (result) {
34 |       terminal.writeTextResult("创建目录成功");
35 |     } else {
36 |       terminal.writeTextErrorResult("创建目录失败");
37 |     }
38 |   },
39 | };
40 | 
41 | export default mkdirCommand;
42 | 


--------------------------------------------------------------------------------
/src/core/commands/user/userStore.ts:
--------------------------------------------------------------------------------
 1 | import { defineStore } from "pinia";
 2 | import { getLoginUser } from "./userApi";
 3 | import { LOCAL_USER } from "./userConstant";
 4 | import UserType = User.UserType;
 5 | 
 6 | /**
 7 |  * 用户系统
 8 |  */
 9 | export const useUserStore = defineStore("user", {
10 |   state: () => ({
11 |     loginUser: {
12 |       ...LOCAL_USER,
13 |     },
14 |   }),
15 |   getters: {},
16 |   // 持久化
17 |   persist: {
18 |     key: "user-store",
19 |     storage: window.localStorage,
20 |     beforeRestore: (context) => {
21 |       console.log("load userStore data start");
22 |     },
23 |     afterRestore: (context) => {
24 |       console.log("load userStore data end");
25 |     },
26 |   },
27 |   actions: {
28 |     async getAndSetLoginUser() {
29 |       const res: any = await getLoginUser();
30 |       if (res?.code === 0 && res.data) {
31 |         this.loginUser = res.data;
32 |       } else {
33 |         console.error("登录失败");
34 |         this.$reset();
35 |       }
36 |     },
37 |     setLoginUser(user: UserType) {
38 |       this.loginUser = user;
39 |     },
40 |   },
41 | });
42 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/music/MusicBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <iframe
 4 |       v-if="musicPath"
 5 |       frameborder="no"
 6 |       marginwidth="0"
 7 |       marginheight="0"
 8 |       width="330"
 9 |       height="86"
10 |       :src="musicPath"
11 |     />
12 |     <div v-if="errorHint">{{ errorHint }}</div>
13 |   </div>
14 | </template>
15 | 
16 | <script setup lang="ts">
17 | import { onMounted, ref, toRefs } from "vue";
18 | import { getSingleMusic } from "./musicApi";
19 | 
20 | interface MusicBoxProps {
21 |   name: string;
22 | }
23 | 
24 | const props = withDefaults(defineProps<MusicBoxProps>(), {});
25 | const { name } = toRefs(props);
26 | const musicPath = ref("");
27 | const errorHint = ref("");
28 | 
29 | onMounted(async () => {
30 |   // 搜索音乐，返回 id
31 |   const res: any = await getSingleMusic(name.value);
32 |   if (res?.code === 0) {
33 |     const music = res.data;
34 |     musicPath.value = `//music.163.com/outchain/player?type=2&id=${music.id}&auto=1&height=66`;
35 |   } else {
36 |     errorHint.value = "未找到音乐";
37 |   }
38 | });
39 | </script>
40 | 
41 | <style scoped></style>
42 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/varbookCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | import { checkSearchText } from "./hooks/character/standard";
 5 | 
 6 | /**
 7 |  * 变量命名命令
 8 |  * @author uiuing
 9 |  */
10 | const varbookCommand: CommandType = {
11 |   func: "varbook",
12 |   name: "varbook",
13 |   desc: "变量命名助手，自动帮你取变量名",
14 |   alias: ["vb", "bianliang"],
15 |   params: [
16 |     {
17 |       key: "data",
18 |       desc: "待转译为变量内容",
19 |       required: true,
20 |     },
21 |   ],
22 |   options: [],
23 |   collapsible: true,
24 |   action(options, terminal) {
25 |     const _ = options._.join(" ");
26 |     const searchText: string | boolean = checkSearchText(_, terminal);
27 |     if (!searchText) return;
28 |     const output: ComponentOutputType = {
29 |       type: "component",
30 |       component: defineAsyncComponent(() => import("./VarbookBox.vue")),
31 |       props: {
32 |         searchText,
33 |       },
34 |     };
35 |     terminal.writeResult(output);
36 |   },
37 | };
38 | 
39 | export default varbookCommand;
40 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikun/IkunBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div style="margin: 8px 0">
 3 |     <canvas ref="canvasRef" class="charVideoCanvas" />
 4 |   </div>
 5 | </template>
 6 | 
 7 | <script setup lang="ts">
 8 | import { onMounted, ref } from "vue";
 9 | // @ts-ignore
10 | import CharVideo from "./charVideo";
11 | 
12 | const getBlob = () => {
13 |   return new Promise((resolve) => {
14 |     const xhr = new XMLHttpRequest();
15 |     xhr.open(
16 |       "GET",
17 |       "https://636f-codenav-8grj8px727565176-1256524210.tcb.qcloud.la/ikun.mp4",
18 |       true
19 |     );
20 |     xhr.responseType = "blob";
21 |     xhr.onload = () => {
22 |       if (xhr.status === 200) {
23 |         resolve(xhr.response);
24 |       }
25 |     };
26 |     xhr.send();
27 |   });
28 | };
29 | 
30 | const canvasRef = ref();
31 | 
32 | onMounted(async () => {
33 |   const blob = await getBlob();
34 |   if (blob) {
35 |     new CharVideo({
36 |       canvasElement: canvasRef.value,
37 |     }).playFile(blob);
38 |   }
39 | });
40 | </script>
41 | 
42 | <style scoped>
43 | .main {
44 |   width: 100%;
45 |   height: 80vh;
46 |   min-height: 600px;
47 | }
48 | </style>
49 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/moyu/MoYuBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div style="margin: 8px 0">
 3 |     <iframe
 4 |       :src="currentGame"
 5 |       class="main"
 6 |       frameborder="no"
 7 |       marginwidth="0"
 8 |       marginheight="0"
 9 |     />
10 |   </div>
11 | </template>
12 | 
13 | <script setup lang="ts">
14 | const gameList = [
15 |   "https://haiyong.site/moyu/shitoujiandaobu/",
16 |   "https://haiyong.site/moyu/lion.html",
17 |   "https://haiyong.site/moyu/shengchengshu.html",
18 |   "https://haiyong.site/moyu/zhipaijiyi.html",
19 |   "https://haiyong.site/moyu/doumao.html",
20 |   "https://haiyong.site/moyu/dadishu.html",
21 |   "https://haiyong.site/moyu/laganziguoguan/",
22 |   "https://haiyong.site/moyu/danzhu.html",
23 |   "https://haiyong.site/moyu/feiji.html",
24 |   "https://haiyong.site/moyu/doudizhu.html",
25 |   "https://haiyong.site/moyu/tiaofangzi.html",
26 |   "https://haiyong.site/moyu/SpaceHuggers/",
27 |   "https://haiyong.site/moyu/weijing/",
28 | ];
29 | 
30 | const currentGame = gameList[Math.floor(Math.random() * gameList.length)];
31 | </script>
32 | 
33 | <style scoped>
34 | .main {
35 |   width: 100%;
36 |   height: 80vh;
37 |   min-height: 600px;
38 | }
39 | </style>
40 | 


--------------------------------------------------------------------------------
/src/core/command.d.ts:
--------------------------------------------------------------------------------
 1 | import { ParsedOptions } from "getopts";
 2 | import TerminalType = YuTerminal.TerminalType;
 3 | 
 4 | /**
 5 |  * 命令类型
 6 |  */
 7 | interface CommandType {
 8 |   // 命令英文 key（必须唯一）
 9 |   func: string;
10 |   // 命令名称
11 |   name: string;
12 |   // 介绍
13 |   desc?: string;
14 |   // 功能别名
15 |   alias?: string[];
16 |   // 参数配置
17 |   params?: CommandParamsType[];
18 |   // 选项配置
19 |   options: CommandOptionType[];
20 |   // 子命令
21 |   subCommands?: Record<string, CommandType>;
22 |   // 执行功能
23 |   action: (
24 |     options: ParsedOptions,
25 |     terminal: TerminalType,
26 |     parentCommand?: CommandType
27 |   ) => void;
28 |   // 结果是否允许折叠
29 |   collapsible?: boolean;
30 | }
31 | 
32 | /**
33 |  * 命令参数类型
34 |  */
35 | interface CommandParamsType {
36 |   key: string; // 参数名
37 |   desc?: string; // 描述
38 |   defaultValue?: string | boolean;
39 |   required?: boolean; // 是否必填
40 | }
41 | 
42 | /**
43 |  * 命令选项类型
44 |  */
45 | interface CommandOptionType {
46 |   key: string; // 参数名，比如 --word
47 |   alias?: string[]; // 命令简写，比如 -w
48 |   desc?: string; // 描述
49 |   type: "string" | "boolean";
50 |   defaultValue?: string | boolean; // 默认值，标识作用
51 |   required?: boolean; // 是否必填
52 | }
53 | 


--------------------------------------------------------------------------------
/src/core/commands/search/baiduCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | 
 3 | /**
 4 |  * 百度搜索命令
 5 |  * @author yupi
 6 |  */
 7 | const baiduCommand: CommandType = {
 8 |   func: "baidu",
 9 |   name: "百度搜索",
10 |   alias: [],
11 |   params: [
12 |     {
13 |       key: "word",
14 |       desc: "搜索内容",
15 |       required: true,
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "self",
21 |       desc: "是否当前页面打开",
22 |       alias: ["s"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |     {
27 |       key: "picture",
28 |       desc: "是否搜索图片",
29 |       alias: ["p"],
30 |       type: "boolean",
31 |       defaultValue: false,
32 |     },
33 |   ],
34 |   action(options, terminal) {
35 |     const { _, self, picture } = options;
36 |     const word = _.length > 0 ? _[0] : "";
37 |     let targetLink = `https://www.baidu.com/s?wd=${word}`;
38 |     // 搜索图片
39 |     if (picture) {
40 |       targetLink = `https://image.baidu.com/search/index?tn=baiduimage&word=${word}`;
41 |     }
42 |     if (self) {
43 |       window.location.href = targetLink;
44 |     } else {
45 |       window.open(targetLink);
46 |     }
47 |   },
48 | };
49 | 
50 | export default baiduCommand;
51 | 


--------------------------------------------------------------------------------
/src/core/commands/space/copyCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { useSpaceStore } from "./spaceStore";
 3 | 
 4 | /**
 5 |  * 复制
 6 |  */
 7 | const copyCommand: CommandType = {
 8 |   func: "copy",
 9 |   name: "复制空间条目",
10 |   alias: ["cp"],
11 |   params: [
12 |     {
13 |       key: "source",
14 |       desc: "来源路径",
15 |       required: true,
16 |     },
17 |     {
18 |       key: "target",
19 |       desc: "目标路径",
20 |       required: true,
21 |     },
22 |   ],
23 |   options: [
24 |     {
25 |       key: "recursive",
26 |       desc: "是否递归复制",
27 |       alias: ["r"],
28 |       type: "boolean",
29 |       defaultValue: false,
30 |     },
31 |   ],
32 |   action(options, terminal): void {
33 |     const { _, recursive = false } = options;
34 |     if (_.length < 2) {
35 |       terminal.writeTextErrorResult("参数不足");
36 |       return;
37 |     }
38 |     const spaceStore = useSpaceStore();
39 |     const [source, target] = _;
40 |     const result = spaceStore.copyItem(source, target, recursive);
41 |     if (result) {
42 |       terminal.writeTextResult("复制成功");
43 |     } else {
44 |       terminal.writeTextErrorResult("复制失败");
45 |     }
46 |   },
47 | };
48 | 
49 | export default copyCommand;
50 | 


--------------------------------------------------------------------------------
/src/core/commands/space/moveCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { useSpaceStore } from "./spaceStore";
 3 | 
 4 | /**
 5 |  * 移动目录（重命名）
 6 |  */
 7 | const moveCommand: CommandType = {
 8 |   func: "move",
 9 |   name: "移动空间条目",
10 |   alias: ["mv"],
11 |   params: [
12 |     {
13 |       key: "source",
14 |       desc: "来源路径",
15 |       required: true,
16 |     },
17 |     {
18 |       key: "target",
19 |       desc: "目标路径",
20 |       required: true,
21 |     },
22 |   ],
23 |   options: [
24 |     {
25 |       key: "recursive",
26 |       desc: "是否递归移动",
27 |       alias: ["r"],
28 |       type: "boolean",
29 |       defaultValue: false,
30 |     },
31 |   ],
32 |   action(options, terminal): void {
33 |     const { _, recursive = false } = options;
34 |     if (_.length < 2) {
35 |       terminal.writeTextErrorResult("参数不足");
36 |       return;
37 |     }
38 |     const spaceStore = useSpaceStore();
39 |     const [source, target] = _;
40 |     const result = spaceStore.moveItem(source, target, recursive);
41 |     if (result) {
42 |       terminal.writeTextResult("移动成功");
43 |     } else {
44 |       terminal.writeTextErrorResult("移动失败");
45 |     }
46 |   },
47 | };
48 | 
49 | export default moveCommand;
50 | 


--------------------------------------------------------------------------------
/src/core/commands/space/listCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { ParsedOptions } from "getopts";
 3 | import { useSpaceStore } from "./spaceStore";
 4 | 
 5 | /**
 6 |  * 列举
 7 |  */
 8 | const listCommand: CommandType = {
 9 |   func: "list",
10 |   name: "列举空间条目",
11 |   alias: ["ls"],
12 |   params: [
13 |     {
14 |       key: "dir",
15 |       desc: "目录",
16 |     },
17 |   ],
18 |   options: [
19 |     {
20 |       key: "recursive",
21 |       desc: "是否递归列举",
22 |       alias: ["r"],
23 |       type: "boolean",
24 |       defaultValue: false,
25 |     },
26 |   ],
27 |   collapsible: true,
28 |   action(options: ParsedOptions, terminal): void {
29 |     const { _, recursive } = options;
30 |     const { listItems, currentDir } = useSpaceStore();
31 |     let dir = _[0] ?? currentDir;
32 |     const resultList = listItems(dir, recursive);
33 |     terminal.writeTextResult(`目录 ${dir}：`);
34 |     resultList.forEach((item) => {
35 |       let output = `${item.name} ${item.link}`;
36 |       if (item.type === "dir") {
37 |         output = `<span style="color: lawngreen">${item.name}</span>`;
38 |       }
39 |       terminal.writeTextResult(output);
40 |     });
41 |   },
42 | };
43 | 
44 | export default listCommand;
45 | 


--------------------------------------------------------------------------------
/src/core/commands/gotoCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../command";
 2 | import { useSpaceStore } from "./space/spaceStore";
 3 | 
 4 | /**
 5 |  * 跳转命令
 6 |  * @author yupi
 7 |  */
 8 | export default {
 9 |   func: "goto",
10 |   name: "网页跳转",
11 |   alias: ["to", "open", "visit", "jump"],
12 |   params: [
13 |     {
14 |       key: "link",
15 |       desc: "目标链接",
16 |       required: true,
17 |     },
18 |   ],
19 |   options: [
20 |     {
21 |       key: "self",
22 |       desc: "是否当前页面打开",
23 |       alias: ["s"],
24 |       type: "boolean",
25 |       defaultValue: false,
26 |     },
27 |   ],
28 |   action(options, terminal): void {
29 |     const { _, self } = options;
30 |     if (_.length < 1) {
31 |       terminal.writeTextErrorResult("参数不足");
32 |       return;
33 |     }
34 |     let link = _[0];
35 |     // 优先找空间条目链接
36 |     let { getItem } = useSpaceStore();
37 |     const item = getItem(link);
38 |     if (item?.link) {
39 |       link = item?.link;
40 |     }
41 |     if (!link.startsWith("http://") && !link.startsWith("https://")) {
42 |       link = "http://" + link;
43 |     }
44 |     if (self) {
45 |       window.location.href = link;
46 |     } else {
47 |       window.open(link);
48 |     }
49 |   },
50 | } as CommandType;
51 | 


--------------------------------------------------------------------------------
/src/core/commands/user/userCommands.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import registerCommand from "./subCommands/registerCommand";
 3 | import loginCommand from "./subCommands/loginCommand";
 4 | import { getLoginUser } from "./userApi";
 5 | import { useUserStore } from "./userStore";
 6 | import { LOCAL_USER } from "./userConstant";
 7 | import logoutCommand from "./subCommands/logoutCommand";
 8 | 
 9 | /**
10 |  * 用户命令
11 |  * @author yupi
12 |  */
13 | const userCommand: CommandType = {
14 |   func: "user",
15 |   name: "用户",
16 |   alias: [],
17 |   params: [
18 |     {
19 |       key: "subCommand",
20 |       desc: "子命令",
21 |       required: true,
22 |     },
23 |   ],
24 |   subCommands: {
25 |     login: loginCommand,
26 |     register: registerCommand,
27 |     logout: logoutCommand,
28 |   },
29 |   options: [],
30 |   async action(options, terminal) {
31 |     const { loginUser } = useUserStore();
32 |     if (loginUser && loginUser.username !== LOCAL_USER.username) {
33 |       let text = `当前用户：${loginUser.username}`;
34 |       if (loginUser.email) {
35 |         text += ` ${loginUser.email}`;
36 |       }
37 |       terminal.writeTextResult(text);
38 |     } else {
39 |       terminal.writeTextErrorResult("未登录，请执行 user login 命令登录");
40 |     }
41 |   },
42 | };
43 | 
44 | export default [userCommand];
45 | 


--------------------------------------------------------------------------------
/src/core/commands/user/subCommands/loginCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { userLogin, userRegister } from "../userApi";
 3 | import { useUserStore } from "../userStore";
 4 | 
 5 | /**
 6 |  * 用户登录命令
 7 |  * @author yupi
 8 |  */
 9 | const loginCommand: CommandType = {
10 |   func: "login",
11 |   name: "用户登录",
12 |   options: [
13 |     {
14 |       key: "username",
15 |       desc: "用户名",
16 |       alias: ["u"],
17 |       type: "string",
18 |       required: true,
19 |     },
20 |     {
21 |       key: "password",
22 |       desc: "密码",
23 |       alias: ["p"],
24 |       type: "string",
25 |       required: true,
26 |     },
27 |   ],
28 |   async action(options, terminal) {
29 |     const { username, password } = options;
30 |     if (!username) {
31 |       terminal.writeTextErrorResult("请输入用户名");
32 |       return;
33 |     }
34 |     if (!password) {
35 |       terminal.writeTextErrorResult("请输入密码");
36 |       return;
37 |     }
38 |     const res: any = await userLogin(username, password);
39 |     const { setLoginUser } = useUserStore();
40 |     if (res?.code === 0) {
41 |       setLoginUser(res.data);
42 |       terminal.writeTextSuccessResult("登录成功");
43 |     } else {
44 |       terminal.writeTextErrorResult(res?.message ?? "登录失败");
45 |     }
46 |   },
47 | };
48 | 
49 | export default loginCommand;
50 | 


--------------------------------------------------------------------------------
/src/core/commands/fanyi/fanyiCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { translate } from "./fanYiApi";
 3 | 
 4 | /**
 5 |  * 翻译命令
 6 |  * @author yupi
 7 |  */
 8 | const fanyiCommand: CommandType = {
 9 |   func: "fanyi",
10 |   name: "翻译",
11 |   alias: [],
12 |   params: [
13 |     {
14 |       key: "word",
15 |       desc: "要翻译的内容",
16 |       required: true,
17 |     },
18 |   ],
19 |   options: [
20 |     {
21 |       key: "from",
22 |       desc: "源语言",
23 |       alias: ["f"],
24 |       type: "string",
25 |       defaultValue: "auto",
26 |     },
27 |     {
28 |       key: "to",
29 |       desc: "目标语言",
30 |       alias: ["t"],
31 |       type: "string",
32 |       defaultValue: "auto",
33 |     },
34 |   ],
35 |   async action(options, terminal) {
36 |     const { _, from, to } = options;
37 |     if (_.length < 1) {
38 |       terminal.writeTextErrorResult("参数不足");
39 |       return;
40 |     }
41 |     const keywords = _.join(" ");
42 |     const res: any = await translate(keywords, {
43 |       from,
44 |       to,
45 |     });
46 |     if (res?.code === 0) {
47 |       terminal.writeTextSuccessResult(
48 |         `翻译结果：${res.data.trans_result[0].dst}`
49 |       );
50 |     } else {
51 |       terminal.writeTextErrorResult(res?.message ?? "翻译失败");
52 |     }
53 |   },
54 | };
55 | 
56 | export default fanyiCommand;
57 | 


--------------------------------------------------------------------------------
/src/core/commands/space/removeCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { ParsedOptions } from "getopts";
 3 | import { useSpaceStore } from "./spaceStore";
 4 | 
 5 | /**
 6 |  * 删除
 7 |  */
 8 | const removeCommand: CommandType = {
 9 |   func: "remove",
10 |   name: "删除空间条目",
11 |   alias: ["rm", "delete", "del"],
12 |   params: [
13 |     {
14 |       key: "item",
15 |       desc: "要删除的条目路径",
16 |       required: true,
17 |     },
18 |   ],
19 |   options: [
20 |     {
21 |       key: "recursive",
22 |       desc: "是否递归删除",
23 |       alias: ["r"],
24 |       type: "boolean",
25 |       defaultValue: false,
26 |     },
27 |     {
28 |       key: "force",
29 |       desc: "是否强制删除",
30 |       alias: ["f"],
31 |       type: "boolean",
32 |       defaultValue: false,
33 |     },
34 |   ],
35 |   action(options: ParsedOptions, terminal): void {
36 |     const { _, recursive = false, force } = options;
37 |     if (_.length < 1) {
38 |       terminal.writeTextErrorResult("参数不足");
39 |       return;
40 |     }
41 |     const deleteKey = _[0];
42 |     if (recursive && !force) {
43 |       terminal.writeTextErrorResult("请确认要强制删除");
44 |       return;
45 |     }
46 |     const spaceStore = useSpaceStore();
47 |     const result = spaceStore.deleteItem(deleteKey, recursive);
48 |     if (result) {
49 |       terminal.writeTextResult("操作成功");
50 |     } else {
51 |       terminal.writeTextErrorResult("操作失败");
52 |     }
53 |   },
54 | };
55 | 
56 | export default removeCommand;
57 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/ContentOutput.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div class="content-output">
 3 |     <template v-if="output.type === 'text'">
 4 |       <a-tag v-if="outputTagColor" :color="outputTagColor"
 5 |         >{{ output.status }}
 6 |       </a-tag>
 7 |       <span v-if="output.type === 'text'" v-html="smartText(output.text)" />
 8 |     </template>
 9 |     <component
10 |       :is="output.component"
11 |       v-if="output.type === 'component'"
12 |       v-bind="output.props ?? {}"
13 |     />
14 |   </div>
15 | </template>
16 | 
17 | <script setup lang="ts">
18 | import smartText from "../../utils/smartText";
19 | import OutputType = YuTerminal.OutputType;
20 | import { computed, toRefs } from "vue";
21 | 
22 | interface OutputProps {
23 |   output: OutputType;
24 | }
25 | 
26 | const props = defineProps<OutputProps>();
27 | const { output } = toRefs(props);
28 | const outputTagColor = computed((): string => {
29 |   if (!output.value.status) {
30 |     return "";
31 |   }
32 |   switch (output.value.status) {
33 |     case "info":
34 |       return "dodgerblue";
35 |     case "success":
36 |       return "limegreen";
37 |     case "warning":
38 |       return "darkorange";
39 |     case "error":
40 |       return "#c0300f";
41 |     case "system":
42 |       return "#bfc4c9";
43 |     default:
44 |       return "";
45 |   }
46 | });
47 | </script>
48 | 
49 | <style scoped>
50 | .content-output :deep(.ant-tag) {
51 |   border-radius: 0;
52 |   font-size: 16px;
53 |   border: none;
54 | }
55 | </style>
56 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/history.ts:
--------------------------------------------------------------------------------
 1 | import { Ref, ref } from "vue";
 2 | import CommandOutputType = YuTerminal.CommandOutputType;
 3 | import CommandInputType = YuTerminal.CommandInputType;
 4 | 
 5 | /**
 6 |  * 查看历史功能
 7 |  * @param commandList
 8 |  * @param inputCommand
 9 |  */
10 | const useHistory = (
11 |   commandList: CommandOutputType[],
12 |   inputCommand: Ref<CommandInputType>
13 | ) => {
14 |   /**
15 |    * 当前查看的命令位置
16 |    */
17 |   const commandHistoryPos = ref(commandList.length);
18 | 
19 |   const listCommandHistory = () => {
20 |     return commandList;
21 |   };
22 | 
23 |   const showNextCommand = () => {
24 |     console.log(commandHistoryPos.value, commandList, inputCommand);
25 |     if (commandHistoryPos.value < commandList.length - 1) {
26 |       commandHistoryPos.value++;
27 |       inputCommand.value.text = commandList[commandHistoryPos.value].text;
28 |     } else if (commandHistoryPos.value === commandList.length - 1) {
29 |       commandHistoryPos.value++;
30 |       inputCommand.value.text = "";
31 |     }
32 |   };
33 | 
34 |   const showPrevCommand = () => {
35 |     console.log(commandHistoryPos.value, commandList, inputCommand);
36 |     if (commandHistoryPos.value >= 1) {
37 |       commandHistoryPos.value--;
38 |       inputCommand.value.text = commandList[commandHistoryPos.value].text;
39 |     }
40 |   };
41 | 
42 |   return {
43 |     commandHistoryPos,
44 |     listCommandHistory,
45 |     showNextCommand,
46 |     showPrevCommand,
47 |   };
48 | };
49 | 
50 | export default useHistory;
51 | 


--------------------------------------------------------------------------------
/src/core/commands/timing/TimingBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div>倒计时：{{ seconds }} 秒</div>
 4 |     <div>
 5 |       剩余：{{ leftTime }} 秒
 6 |       <template v-if="leftTime > 0">
 7 |         <a-button v-if="start" size="small" ghost danger @click="toggleStart">
 8 |           暂停
 9 |         </a-button>
10 |         <a-button v-else size="small" ghost @click="toggleStart">继续</a-button>
11 |       </template>
12 |     </div>
13 |   </div>
14 | </template>
15 | 
16 | <script setup lang="ts">
17 | import { onMounted, onUnmounted, ref, toRefs } from "vue";
18 | 
19 | interface TimingBoxProps {
20 |   seconds: string;
21 | }
22 | 
23 | const props = withDefaults(defineProps<TimingBoxProps>(), {});
24 | const { seconds } = toRefs(props);
25 | 
26 | // 剩余时间
27 | const leftTime = ref(Number(seconds.value));
28 | // 运行中
29 | const start = ref(true);
30 | // 定时器
31 | let interval: number;
32 | 
33 | /**
34 |  * 暂停 / 运行
35 |  */
36 | const toggleStart = () => {
37 |   start.value = !start.value;
38 | };
39 | 
40 | onMounted(() => {
41 |   if (!leftTime.value) {
42 |     return;
43 |   }
44 |   interval = window.setInterval(() => {
45 |     if (start.value) {
46 |       leftTime.value--;
47 |     }
48 |     if (leftTime.value <= 0) {
49 |       alert(`${seconds.value} 秒倒计时结束`);
50 |       if (interval) {
51 |         clearInterval(interval);
52 |       }
53 |     }
54 |   }, 1000);
55 | });
56 | 
57 | onUnmounted(() => {
58 |   if (interval) {
59 |     clearInterval(interval);
60 |   }
61 | });
62 | </script>
63 | 
64 | <style scoped></style>
65 | 


--------------------------------------------------------------------------------
/src/core/commands/user/subCommands/registerCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { getSingleMusic } from "../../relax/music/musicApi";
 3 | import { userRegister } from "../userApi";
 4 | 
 5 | /**
 6 |  * 用户注册命令
 7 |  * @author yupi
 8 |  */
 9 | const registerCommand: CommandType = {
10 |   func: "register",
11 |   name: "用户注册",
12 |   options: [
13 |     {
14 |       key: "username",
15 |       desc: "用户名",
16 |       alias: ["u"],
17 |       type: "string",
18 |       required: true,
19 |     },
20 |     {
21 |       key: "password",
22 |       desc: "密码",
23 |       alias: ["p"],
24 |       type: "string",
25 |       required: true,
26 |     },
27 |     {
28 |       key: "email",
29 |       desc: "邮箱",
30 |       alias: ["e"],
31 |       type: "string",
32 |       required: true,
33 |     },
34 |   ],
35 |   async action(options, terminal) {
36 |     const { username, password, email } = options;
37 |     if (!username) {
38 |       terminal.writeTextErrorResult("请输入用户名");
39 |       return;
40 |     }
41 |     if (!password) {
42 |       terminal.writeTextErrorResult("请输入密码");
43 |       return;
44 |     }
45 |     if (!email) {
46 |       terminal.writeTextErrorResult("请输入邮箱");
47 |       return;
48 |     }
49 |     const res: any = await userRegister(username, password, email);
50 |     if (res?.code === 0) {
51 |       terminal.writeTextSuccessResult("注册成功");
52 |     } else {
53 |       terminal.writeTextErrorResult(res?.message ?? "注册失败");
54 |     }
55 |   },
56 | };
57 | 
58 | export default registerCommand;
59 | 


--------------------------------------------------------------------------------
/src/core/commands/todo/TodoBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div style="margin: 8px 0; max-width: 600px">
 3 |     <a-card body-style="padding: 0 12px">
 4 |       <a-list item-layout="horizontal" :data-source="taskList">
 5 |         <template #renderItem="{ item, index }">
 6 |           <a-list-item>
 7 |             <template #actions>
 8 |               <a-button type="text" danger @click="doDelete(index)"
 9 |                 >删除
10 |               </a-button>
11 |             </template>
12 |             <a-list-item-meta>
13 |               <template #title>
14 |                 {{ item.name }}
15 |               </template>
16 |               <template #description>
17 |                 创建时间：{{
18 |                   MyDayjs(item.createTime).format("YYYY-MM-DD HH:mm:ss")
19 |                 }}
20 |               </template>
21 |               <template #avatar>
22 |                 <a-checkbox v-model:checked="item.isFinished" />
23 |               </template>
24 |             </a-list-item-meta>
25 |           </a-list-item>
26 |         </template>
27 |       </a-list>
28 |     </a-card>
29 |   </div>
30 | </template>
31 | 
32 | <script setup lang="ts">
33 | import { toRefs } from "vue";
34 | import { useTodoStore } from "./todoStore";
35 | import MyDayjs from "../../../plugins/myDayjs";
36 | 
37 | interface TodoBoxProps {
38 |   today: boolean;
39 | }
40 | 
41 | const props = withDefaults(defineProps<TodoBoxProps>(), {});
42 | const { today } = toRefs(props);
43 | 
44 | const { taskList, deleteTask } = useTodoStore();
45 | 
46 | const doDelete = (index: number) => {
47 |   deleteTask(index);
48 | };
49 | </script>
50 | 
51 | <style scoped></style>
52 | 


--------------------------------------------------------------------------------
/src/core/commands/search/bilibili/bilibiliCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 4 | 
 5 | const baseUrl = "https://www.baidu.com/s";
 6 | 
 7 | /**
 8 |  * B 站搜索命令
 9 |  * @author yupi
10 |  */
11 | const bilibiliCommand: CommandType = {
12 |   func: "bilibili",
13 |   name: "bilibili 搜索",
14 |   alias: ["bzhan", "bili"],
15 |   params: [
16 |     {
17 |       key: "word",
18 |       desc: "搜索内容",
19 |       required: true,
20 |     },
21 |   ],
22 |   options: [
23 |     {
24 |       key: "self",
25 |       desc: "是否当前页面打开",
26 |       alias: ["s"],
27 |       type: "boolean",
28 |       defaultValue: false,
29 |     },
30 |     {
31 |       key: "bvid",
32 |       desc: "B站视频id",
33 |       alias: ["b"],
34 |       type: "string",
35 |     },
36 |   ],
37 |   collapsible: true,
38 |   action(options, terminal) {
39 |     const { _, self, bvid } = options;
40 |     // 优先打开视频
41 |     if (bvid) {
42 |       const output: ComponentOutputType = {
43 |         type: "component",
44 |         component: defineAsyncComponent(() => import("./BilibiliBox.vue")),
45 |         props: {
46 |           bvid,
47 |         },
48 |       };
49 |       terminal.writeResult(output);
50 |       return;
51 |     }
52 |     const word = _.length > 0 ? _[0] : "";
53 |     const targetLink = `https://search.bilibili.com/all?keyword=${word}`;
54 |     if (self) {
55 |       window.location.href = targetLink;
56 |     } else {
57 |       window.open(targetLink);
58 |     }
59 |   },
60 | };
61 | 
62 | export default bilibiliCommand;
63 | 


--------------------------------------------------------------------------------
/src/core/commands/space/addCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import { useSpaceStore } from "./spaceStore";
 3 | import { SpaceItemType } from "./spaceCommands";
 4 | 
 5 | /**
 6 |  * 新增
 7 |  */
 8 | const addCommand: CommandType = {
 9 |   func: "add",
10 |   name: "新增空间条目",
11 |   alias: ["touch", "new"],
12 |   options: [
13 |     {
14 |       key: "name",
15 |       desc: "条目名称",
16 |       alias: ["n"],
17 |       type: "string",
18 |       required: true,
19 |     },
20 |     {
21 |       key: "link",
22 |       desc: "链接",
23 |       alias: ["l"],
24 |       type: "string",
25 |       required: true,
26 |     },
27 |     {
28 |       key: "dir",
29 |       desc: "目标目录",
30 |       alias: ["d"],
31 |       type: "string",
32 |     },
33 |   ],
34 |   action(options, terminal): void {
35 |     let { _, name, link, dir } = options;
36 |     const spaceStore = useSpaceStore();
37 |     if (!dir) {
38 |       dir = spaceStore.currentDir;
39 |     }
40 |     if (!name) {
41 |       terminal.writeTextResult("请输入名称");
42 |       return;
43 |     }
44 |     if (!link) {
45 |       terminal.writeTextResult("请输入网址");
46 |       return;
47 |     }
48 |     if (!link.startsWith("http://") && !link.startsWith("https://")) {
49 |       link = "http://" + link;
50 |     }
51 |     const item: SpaceItemType = {
52 |       dir,
53 |       link,
54 |       name,
55 |       type: "link",
56 |     };
57 |     const result = spaceStore.addItem(item);
58 |     if (result) {
59 |       terminal.writeTextResult("添加成功");
60 |     } else {
61 |       terminal.writeTextErrorResult("添加失败");
62 |     }
63 |   },
64 | };
65 | 
66 | export default addCommand;
67 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/hint.ts:
--------------------------------------------------------------------------------
 1 | import { ref } from "vue";
 2 | import { getUsageStr } from "../../core/commands/terminal/help/helpUtils";
 3 | import { commandMap } from "../../core/commandRegister";
 4 | import _, { trim } from "lodash";
 5 | import { useTerminalConfigStore } from "../../core/commands/terminal/config/terminalConfigStore";
 6 | 
 7 | /**
 8 |  * 命令提示功能
 9 |  * @author yupi
10 |  */
11 | const useHint = () => {
12 |   const hint = ref("");
13 |   const { showHint } = useTerminalConfigStore();
14 | 
15 |   const setHint = (inputText: string) => {
16 |     // 未开启提示
17 |     if (!showHint) {
18 |       return;
19 |     }
20 |     if (!inputText) {
21 |       hint.value = "";
22 |       return;
23 |     }
24 |     const args = trim(inputText).split(" ");
25 |     // 大小写无关
26 |     let func = args[0].toLowerCase();
27 |     // 前缀匹配
28 |     const likeKey = Object.keys(commandMap).filter((key) =>
29 |       key.startsWith(func)
30 |     )[0];
31 |     let command = commandMap[likeKey];
32 |     if (!command) {
33 |       hint.value = "";
34 |       return;
35 |     }
36 |     // 子命令提示
37 |     if (
38 |       command.subCommands &&
39 |       Object.keys(command.subCommands).length > 0 &&
40 |       args.length > 1
41 |     ) {
42 |       hint.value = getUsageStr(command.subCommands[args[1]], command);
43 |     } else {
44 |       hint.value = getUsageStr(command);
45 |     }
46 |   };
47 | 
48 |   /**
49 |    * 输入提示防抖
50 |    */
51 |   const debounceSetHint = _.debounce(function (inputText: string) {
52 |     setHint(inputText);
53 |   }, 500);
54 | 
55 |   return {
56 |     hint,
57 |     setHint,
58 |     debounceSetHint,
59 |   };
60 | };
61 | 
62 | export default useHint;
63 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/config/terminalConfigStore.ts:
--------------------------------------------------------------------------------
 1 | import { defineStore } from "pinia";
 2 | 
 3 | /**
 4 |  * 终端配置状态存储
 5 |  *
 6 |  * @author yupi
 7 |  */
 8 | export const useTerminalConfigStore = defineStore("terminalConfig", {
 9 |   state: () => ({
10 |     // 背景
11 |     background: "black",
12 |     // 输入提示
13 |     showHint: true,
14 |     // 终端欢迎语
15 |     welcomeTexts: [] as string[],
16 |   }),
17 |   getters: {},
18 |   // 持久化
19 |   persist: {
20 |     key: "terminal-config-store",
21 |     storage: window.localStorage,
22 |     beforeRestore: (context) => {
23 |       console.log("load terminalConfigStore data start");
24 |     },
25 |     afterRestore: (context) => {
26 |       console.log("load terminalConfigStore data end");
27 |     },
28 |   },
29 |   actions: {
30 |     setBackground(url: string) {
31 |       if (!url) {
32 |         return;
33 |       }
34 |       this.background = url;
35 |     },
36 |     /**
37 |      * 设置或反转提示
38 |      * @param hint
39 |      * @return 修改后的提示开启 / 关闭状态
40 |      */
41 |     setOrToggleShowHint(hint?: string): boolean {
42 |       // 反转提示
43 |       if (!hint) {
44 |         this.showHint = !this.showHint;
45 |         return this.showHint;
46 |       }
47 |       // 设置提示
48 |       if (hint === "on") {
49 |         this.showHint = true;
50 |       } else if (hint === "off") {
51 |         this.showHint = false;
52 |       }
53 |       return this.showHint;
54 |     },
55 |     /**
56 |      * 修改终端提示语
57 |      * @param welcomeTexts
58 |      */
59 |     setWelcomeTexts(welcomeTexts: string[]) {
60 |       this.welcomeTexts = welcomeTexts;
61 |     },
62 |     reset() {
63 |       this.$reset();
64 |     },
65 |   },
66 | });
67 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/help/helpCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../../command";
 2 | import { defineAsyncComponent } from "vue";
 3 | import { commandMap } from "../../../commandRegister";
 4 | import ComponentOutputType = YuTerminal.ComponentOutputType;
 5 | 
 6 | /**
 7 |  * 帮助命令
 8 |  * @author yupi
 9 |  */
10 | const helpCommand: CommandType = {
11 |   func: "help",
12 |   name: "查看帮助",
13 |   alias: ["man"],
14 |   params: [
15 |     {
16 |       key: "commandName",
17 |       desc: "命令英文名称",
18 |     },
19 |   ],
20 |   options: [],
21 |   collapsible: true,
22 |   action(options, terminal, parentCommand): void {
23 |     const { _ } = options;
24 |     // 输出所有帮助（文档 + 命令列表）
25 |     if (_.length < 1) {
26 |       const output: ComponentOutputType = {
27 |         type: "component",
28 |         component: defineAsyncComponent(() => import("./HelpBox.vue")),
29 |       };
30 |       terminal.writeResult(output);
31 |       return;
32 |     }
33 |     // 输出某个命令的帮助
34 |     const commandName = _[0];
35 |     let commands = commandMap;
36 |     // 支持输出子命令的帮助
37 |     if (
38 |       parentCommand &&
39 |       parentCommand.subCommands &&
40 |       Object.keys(parentCommand.subCommands).length > 0
41 |     ) {
42 |       commands = parentCommand.subCommands;
43 |     }
44 |     const command = commands[commandName];
45 |     if (!command) {
46 |       terminal.writeTextErrorResult("找不到指定命令");
47 |       return;
48 |     }
49 |     const output: ComponentOutputType = {
50 |       type: "component",
51 |       component: defineAsyncComponent(() => import("./CommandHelpBox.vue")),
52 |       props: {
53 |         command,
54 |         parentCommand,
55 |       },
56 |     };
57 |     terminal.writeResult(output);
58 |   },
59 | };
60 | 
61 | export default helpCommand;
62 | 


--------------------------------------------------------------------------------
/src/core/commands/todo/todoStore.ts:
--------------------------------------------------------------------------------
 1 | import { defineStore } from "pinia";
 2 | import TaskType = Todo.TaskType;
 3 | 
 4 | /**
 5 |  * 空间状态（类似文件系统实现）
 6 |  */
 7 | export const useTodoStore = defineStore("todo", {
 8 |   state: () => ({
 9 |     // 任务列表
10 |     taskList: [
11 |       {
12 |         name: "写下你要做的事",
13 |         isFinished: false,
14 |         createTime: new Date(),
15 |       },
16 |       {
17 |         name: "已完成的事项",
18 |         isFinished: true,
19 |         createTime: new Date(),
20 |       },
21 |     ] as TaskType[],
22 |   }),
23 |   getters: {},
24 |   // 持久化
25 |   persist: {
26 |     key: "todo-store",
27 |     storage: window.localStorage,
28 |     beforeRestore: (context) => {
29 |       console.log("load todoStore data start");
30 |     },
31 |     afterRestore: (context) => {
32 |       console.log("load todoStore data end");
33 |     },
34 |   },
35 |   actions: {
36 |     /**
37 |      * 创建任务
38 |      * @param task
39 |      */
40 |     addTask(task: TaskType) {
41 |       if (!task || !task.name) {
42 |         return false;
43 |       }
44 |       task.isFinished = false;
45 |       task.createTime = new Date();
46 |       this.taskList.push(task);
47 |       return true;
48 |     },
49 |     /**
50 |      * 删除任务
51 |      * @param index
52 |      */
53 |     deleteTask(index: number) {
54 |       if (index < 0 || index >= this.taskList.length) {
55 |         return false;
56 |       }
57 |       this.taskList.splice(index, 1);
58 |       return true;
59 |     },
60 |     /**
61 |      * 更新任务
62 |      * @param index
63 |      * @param newTask
64 |      */
65 |     updateTask(index: number, newTask: TaskType) {
66 |       if (index < 0 || index >= this.taskList.length) {
67 |         return false;
68 |       }
69 |       this.taskList[index] = { ...this.taskList[index], ...newTask };
70 |     },
71 |   },
72 | });
73 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/hooks/character/standard.ts:
--------------------------------------------------------------------------------
 1 | import TerminalType = YuTerminal.TerminalType;
 2 | 
 3 | const STYLE_LANG: { [key: string]: string } = {
 4 |   smallHump: "小驼峰",
 5 |   bigHump: "大驼峰",
 6 |   smallSnake: "小蛇形",
 7 |   bigSnake: "大蛇形",
 8 |   spinal: "脊柱",
 9 |   note: "注释",
10 | };
11 | 
12 | /**
13 |  * 解析搜索文本
14 |  * @param content
15 |  */
16 | const parseSearchText = (content: string): string | null | undefined => {
17 |   return content
18 |     ? content
19 |         .trim()
20 |         .match(/[a-zA-Z0-9\s\u4e00-\u9fa5\uF900-\uFA2D]+/gi)
21 |         ?.join("")
22 |         .replaceAll(/\s+/g, " ")
23 |     : content;
24 | };
25 | 
26 | /**
27 |  * 检查搜索文本
28 |  * @param searchText
29 |  * @param terminal
30 |  */
31 | export const checkSearchText = (
32 |   searchText: string,
33 |   terminal: TerminalType
34 | ): string | boolean => {
35 |   const newSearchText: string | null | undefined = parseSearchText(searchText);
36 |   if (!newSearchText || Number(newSearchText) || newSearchText.length < 2) {
37 |     terminal.writeTextErrorResult(
38 |       "内容过短，至少2个纯数字以外的字符（1个汉字、字母、空格、数字计为一个字符）"
39 |     );
40 |     return false;
41 |   }
42 |   if (newSearchText.length > 15) {
43 |     terminal.writeTextErrorResult(
44 |       "内容过长，应小于15个字符（1个汉字、字母、空格、数字计为一个字符）"
45 |     );
46 |     return false;
47 |   }
48 |   return newSearchText;
49 | };
50 | 
51 | export const parseNamedVariable = (
52 |   namedVariables: any
53 | ): {
54 |   columns: any[];
55 |   source: any[];
56 | } => {
57 |   const source = [];
58 |   for (const key in STYLE_LANG) {
59 |     source.push({
60 |       style: STYLE_LANG[key],
61 |       key,
62 |       data: namedVariables[key],
63 |     });
64 |   }
65 |   return {
66 |     source,
67 |     columns: [
68 |       {
69 |         title: "变量命名法",
70 |         dataIndex: "style",
71 |         key: "style",
72 |         width: "100px",
73 |       },
74 |       {
75 |         title: "变量名",
76 |         dataIndex: "data",
77 |         key: "data",
78 |         align: "center",
79 |       },
80 |     ],
81 |   };
82 | };
83 | 


--------------------------------------------------------------------------------
/src/core/commands/pingCommand.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../command";
 2 | //import axios from "axios";
 3 | 
 4 | /**
 5 |  * ping 命令
 6 |  * @author yupi
 7 |  */
 8 | const pingCommand: CommandType = {
 9 |   func: "ping",
10 |   name: "ping",
11 |   desc: "检测某个地址是否存活",
12 |   params: [
13 |     {
14 |       key: "dest",
15 |       desc: "目标地址",
16 |       required: true,
17 |     },
18 |   ],
19 |   options: [
20 |     {
21 |       key: "timeout",
22 |       desc: "请求超时时间(单位:毫秒)",
23 |       alias: ["t"],
24 |       type: "string",
25 |       defaultValue: "3000",
26 |     },
27 |   ],
28 |   async action(options, terminal) {
29 |     const { _ } = options;
30 |     const { timeout = "3000" } = options;
31 |     if (_.length < 1) {
32 |       terminal.writeTextErrorResult("参数不足");
33 |       return;
34 |     }
35 |     var dest = _[0];
36 |     if (
37 |       !dest.toLowerCase().startsWith("http://") &&
38 |       !dest.toLowerCase().startsWith("https://")
39 |     ) {
40 |       dest = "https://" + dest;
41 |     }
42 |     if (dest.toLowerCase().startsWith("http://")) {
43 |       dest = dest.replace("http://", "https://");
44 |     }
45 |     const startTime = new Date().getTime();
46 |     const res = await Promise.race([
47 |       new Promise(function (resolve, reject) {
48 |         setTimeout(() => reject(new Error("timeout")), Number(timeout));
49 |       }),
50 |       fetch(dest, { mode: "no-cors", cache: "reload" }),
51 |     ])
52 |       .then((resp: any) => {
53 |         if (resp.ok || resp.status == 200 || resp.type == "opaque") {
54 |           console.log(resp);
55 |           const finishTime = new Date().getTime();
56 |           terminal.writeTextSuccessResult("目标地址正常");
57 |           terminal.writeTextResult(
58 |             `延迟=${(finishTime - startTime).toString()}ms`
59 |           );
60 |         } else {
61 |           terminal.writeTextErrorResult("ping 不通！");
62 |         }
63 |       })
64 |       .catch((error) => {
65 |         console.log(error);
66 |         terminal.writeTextErrorResult("ping 不通！");
67 |       });
68 |   },
69 | };
70 | 
71 | export default pingCommand;
72 | 


--------------------------------------------------------------------------------
/src/core/commands/varbook/VarbookBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div :class="['main', variablesTable.source ? 'success' : 'warning']">
 3 |     <a-spin
 4 |       :spinning="!loadOK"
 5 |       :style="{
 6 |         height: !loadOK ? '283px' : '',
 7 |         position: !loadOK ? 'inherit' : '',
 8 |       }"
 9 |     >
10 |       <div v-show="loadOK">
11 |         <a-table
12 |           v-if="variablesTable?.source"
13 |           class="table"
14 |           :data-source="variablesTable?.source"
15 |           :columns="variablesTable?.columns"
16 |           :size="'small'"
17 |           :pagination="false"
18 |         />
19 |         <content-output v-else :output="output" />
20 |       </div>
21 |     </a-spin>
22 |   </div>
23 | </template>
24 | 
25 | <script setup lang="ts">
26 | import { reactive, ref, toRefs } from "vue";
27 | import { getNamedVariables } from "./hooks/api/rest/translate";
28 | import { parseNamedVariable } from "./hooks/character/standard";
29 | import ContentOutput from "../../../components/yu-terminal/ContentOutput.vue";
30 | import OutputType = YuTerminal.OutputType;
31 | 
32 | interface VariableBoxProps {
33 |   searchText: string;
34 | }
35 | 
36 | const props = defineProps<VariableBoxProps>();
37 | 
38 | const { searchText } = toRefs(props);
39 | const variablesTable = ref<any>({});
40 | const loadOK = ref(false);
41 | const output = reactive<OutputType>({
42 |   type: "text",
43 |   status: "warning",
44 |   text: "",
45 | });
46 | 
47 | getNamedVariables(searchText.value)
48 |   .then((res: any) => {
49 |     const { code, data, msg } = res;
50 |     code === 200
51 |       ? (variablesTable.value = parseNamedVariable(data.namedVariables))
52 |       : (output.text = msg);
53 |   })
54 |   .catch((err: any) => {
55 |     output.text = "服务器扛不住了，请稍后再试";
56 |   })
57 |   .finally(() => {
58 |     loadOK.value = true;
59 |   });
60 | </script>
61 | 
62 | <style scoped>
63 | .main {
64 |   max-width: 600px;
65 | }
66 | 
67 | .success {
68 |   margin: 8px 0;
69 | }
70 | 
71 | .warning {
72 |   margin: 0;
73 | }
74 | 
75 | .table {
76 |   overflow: hidden;
77 |   background-color: white;
78 |   padding: 5px;
79 |   border-radius: 10px;
80 |   box-shadow: 2px 3px 3px 1px #8b8b8b59;
81 | }
82 | </style>
83 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/type.d.ts:
--------------------------------------------------------------------------------
 1 | declare namespace YuTerminal {
 2 |   /**
 3 |    * 输出状态
 4 |    */
 5 |   type OutputStatusType = "info" | "success" | "warning" | "error" | "system";
 6 | 
 7 |   /**
 8 |    * 输出类型
 9 |    */
10 |   interface OutputType {
11 |     type: "command" | "text" | "component";
12 |     text?: string;
13 |     resultList?: OutputType[];
14 |     component?: any;
15 |     status?: OutputStatusType;
16 |     props?: any;
17 |     collapsible?: boolean;
18 |   }
19 | 
20 |   /**
21 |    * 命令类型输出
22 |    */
23 |   interface CommandOutputType extends OutputType {
24 |     type: "command";
25 |     text: string;
26 |     resultList: OutputType[];
27 |   }
28 | 
29 |   /**
30 |    * 文本类型输出
31 |    */
32 |   interface TextOutputType extends OutputType {
33 |     type: "text";
34 |     text: string;
35 |   }
36 | 
37 |   /**
38 |    * 组件类型输出
39 |    */
40 |   interface ComponentOutputType extends OutputType {
41 |     type: "component";
42 |     component: any;
43 |     props?: any;
44 |   }
45 | 
46 |   /**
47 |    * 命令输入类型
48 |    */
49 |   interface CommandInputType {
50 |     text: string;
51 |     placeholder?: string;
52 |   }
53 | 
54 |   /**
55 |    * 终端类型（定义一组访问及操作终端的方法）
56 |    */
57 |   interface TerminalType {
58 |     // 清屏
59 |     clear: () => void;
60 |     // 立即输出
61 |     writeOutput: (output: OutputType) => void;
62 |     // 立即输出文本
63 |     writeTextOutput: (text: string, status?: OutputStatusType) => void;
64 |     // 写命令文本结果
65 |     writeTextResult: (text: string, status?: OutputStatusType) => void;
66 |     // 写命令错误文本结果
67 |     writeTextErrorResult: (text: string) => void;
68 |     // 写命令成功文本结果
69 |     writeTextSuccessResult: (text: string) => void;
70 |     // 写命令结果
71 |     writeResult: (output: OutputType) => void;
72 |     // 输入框聚焦
73 |     focusInput: () => void;
74 |     // 获取输入框是否聚焦
75 |     isInputFocused: () => boolean;
76 |     // 设置输入框的值
77 |     setTabCompletion: () => void;
78 |     // 提交命令
79 |     doSubmitCommand: () => void;
80 |     // 查看下一条命令
81 |     showNextCommand: () => void;
82 |     // 查看上一条命令
83 |     showPrevCommand: () => void;
84 |     // 查看历史命令
85 |     listCommandHistory: () => CommandOutputType[];
86 |     // 折叠 / 展开所有块
87 |     toggleAllCollapse: () => void;
88 |     // 设置命令是否可折叠
89 |     setCommandCollapsible: (collapsible: boolean) => void;
90 |   }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/help/CommandHelpBox.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <div>
 3 |     <div>命令：{{ command.name }}</div>
 4 |     <div v-if="command.desc">介绍：{{ command.desc }}</div>
 5 |     <div v-if="command.alias && command.alias.length > 0">
 6 |       别名：{{ command.alias.join(", ") }}
 7 |     </div>
 8 |     <div>用法：{{ usageStr }}</div>
 9 |     <template
10 |       v-if="command.subCommands && Object.keys(command.subCommands).length > 0"
11 |     >
12 |       <div>子命令：</div>
13 |       <ul style="margin-bottom: 0">
14 |         <li
15 |           v-for="(subCommand, key, index) in command.subCommands"
16 |           :key="index"
17 |         >
18 |           {{ subCommand.func }}
19 |           {{ subCommand.name }}
20 |           {{ subCommand.desc }}
21 |         </li>
22 |       </ul>
23 |     </template>
24 |     <template v-if="command.params && command.params.length > 0">
25 |       <div>参数：</div>
26 |       <ul style="margin-bottom: 0">
27 |         <li v-for="(param, index) in command.params" :key="index">
28 |           {{ param.key }}
29 |           {{ param.required ? "必填" : "可选" }}
30 |           {{ param.defaultValue ? `默认：${param.defaultValue}` : "" }}
31 |           {{ param.desc }}
32 |         </li>
33 |       </ul>
34 |     </template>
35 |     <template v-if="command.options?.length > 0">
36 |       <div>选项：</div>
37 |       <ul style="margin-bottom: 0">
38 |         <li v-for="(option, index) in command.options" :key="index">
39 |           {{ getOptionKeyList(option).join(", ") }}
40 |           {{ option.required ? "必填" : "可选" }}
41 |           {{ option.defaultValue ? `默认：${option.defaultValue}` : "" }}
42 |           {{ option.desc }}
43 |         </li>
44 |       </ul>
45 |     </template>
46 |   </div>
47 | </template>
48 | 
49 | <script setup lang="ts">
50 | import { computed, onMounted, toRefs } from "vue";
51 | import { CommandType } from "../../../command";
52 | import { getUsageStr, getOptionKeyList } from "./helpUtils";
53 | 
54 | interface HelpBoxProps {
55 |   command: CommandType;
56 |   parentCommand: CommandType;
57 | }
58 | 
59 | const props = withDefaults(defineProps<HelpBoxProps>(), {});
60 | const { command, parentCommand } = toRefs(props);
61 | 
62 | /**
63 |  * 拼接用法字符串
64 |  */
65 | const usageStr = computed(() => {
66 |   return getUsageStr(command.value, parentCommand.value);
67 | });
68 | 
69 | onMounted(() => {});
70 | </script>
71 | 
72 | <style scoped></style>
73 | 


--------------------------------------------------------------------------------
/src/core/commands/terminal/help/helpUtils.ts:
--------------------------------------------------------------------------------
 1 | import { CommandOptionType, CommandType } from "../../../command";
 2 | 
 3 | /**
 4 |  * 拼接用法字符串
 5 |  * @param command
 6 |  * @param parentCommand
 7 |  */
 8 | export const getUsageStr = (
 9 |   command: CommandType,
10 |   parentCommand?: CommandType
11 | ) => {
12 |   if (!command) {
13 |     return "";
14 |   }
15 |   let str = "";
16 |   if (parentCommand) {
17 |     str = parentCommand.func + " ";
18 |   }
19 |   str += command.func;
20 |   if (command.params && command.params.length > 0) {
21 |     const paramsStrList: string[] = command.params.map((param) => {
22 |       let word = param.key;
23 |       if (param.desc) {
24 |         word = param.desc;
25 |       }
26 |       if (param.required) {
27 |         return `<${word}>`;
28 |       } else {
29 |         return `[${word}]`;
30 |       }
31 |     });
32 |     str += " " + paramsStrList.join(" ");
33 |   }
34 |   if (command.options?.length > 0) {
35 |     const optionStrList: string[] = command.options.map((option) => {
36 |       const optionKey = getOptionKey(option);
37 |       if (option.type === "boolean") {
38 |         let word = optionKey;
39 |         if (option.desc) {
40 |           word += ` ${option.desc}`;
41 |         }
42 |         if (option.required) {
43 |           return `<${word}>`;
44 |         } else {
45 |           return `[${word}]`;
46 |         }
47 |       } else {
48 |         let word = option.key;
49 |         if (option.desc) {
50 |           word = option.desc;
51 |         }
52 |         if (option.required) {
53 |           return `<${optionKey} ${word}>`;
54 |         } else {
55 |           return `[${optionKey} ${word}]`;
56 |         }
57 |       }
58 |     });
59 |     str += " " + optionStrList.join(" ");
60 |   }
61 |   return str;
62 | };
63 | 
64 | /**
65 |  * 获取选项关键词
66 |  * @param option
67 |  */
68 | export const getOptionKey = (option: CommandOptionType) => {
69 |   // 优先用简写
70 |   if (option.alias && option.alias.length > 0) {
71 |     return "-" + option.alias[0];
72 |   }
73 |   return "--" + option.key;
74 | };
75 | 
76 | /**
77 |  * 获取选项关键词列表
78 |  * @param option
79 |  */
80 | export const getOptionKeyList = (option: CommandOptionType) => {
81 |   const list = [];
82 |   // 优先用简写
83 |   if (option.alias && option.alias.length > 0) {
84 |     list.push("-" + option.alias[0]);
85 |   }
86 |   list.push("--" + option.key);
87 |   return list;
88 | };
89 | 


--------------------------------------------------------------------------------
/src/core/commands/search/searchCommands.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "../../command";
 2 | import baiduCommand from "./baiduCommand";
 3 | import baidudevCommand from "./baidudevCommand";
 4 | import bilibiliCommand from "./bilibili/bilibiliCommand";
 5 | import bingCommand from "./bingCommand";
 6 | import codenavCommand from "./codenavCommand";
 7 | import doubanCommand from "./doubanCommand";
 8 | import douyinCommand from "./douyinCommand";
 9 | import githubCommand from "./githubCommand";
10 | import googleCommand from "./googleCommand";
11 | import wangyiyunCommand from "./wangyiyunCommand";
12 | import zhihuCommand from "./zhihuCommand";
13 | import gengCommand from "./gengCommand";
14 | import duckduckgoCommand from "./duckduckgoCommand";
15 | import fsearchCommand from "./fsearchCommand";
16 | import sogouCommand from "./sogouCommand";
17 | import mdnCommand from "./mdnCommand"
18 | 
19 | /**
20 |  * 搜索源
21 |  */
22 | const fromDict: Record<string, CommandType> = {
23 |   baidu: baiduCommand,
24 |   baidudev: baidudevCommand,
25 |   bilibili: bilibiliCommand,
26 |   bing: bingCommand,
27 |   codenav: codenavCommand,
28 |   douban: doubanCommand,
29 |   douyin: douyinCommand,
30 |   duckduckgo: duckduckgoCommand,
31 |   fsearch: fsearchCommand,
32 |   github: githubCommand,
33 |   google: googleCommand,
34 |   sogou: sogouCommand,
35 |   wangyiyun: wangyiyunCommand,
36 |   zhihu: zhihuCommand,
37 |   geng: gengCommand,
38 |   mdn: mdnCommand
39 | };
40 | 
41 | /**
42 |  * 搜索命令
43 |  * @author yupi
44 |  */
45 | const searchCommand: CommandType = {
46 |   func: "search",
47 |   name: "网页搜索",
48 |   alias: ["s", "sousuo", "sou", "query"],
49 |   desc: "支持从不同平台快捷搜索内容",
50 |   params: [
51 |     {
52 |       key: "word",
53 |       desc: "搜索内容",
54 |       required: true,
55 |     },
56 |   ],
57 |   options: [
58 |     {
59 |       // 来源
60 |       key: "from",
61 |       alias: ["f"],
62 |       type: "string",
63 |       defaultValue: "baidu",
64 |     },
65 |     {
66 |       key: "self",
67 |       desc: "是否当前页面打开",
68 |       alias: ["s"],
69 |       type: "boolean",
70 |       defaultValue: false,
71 |     },
72 |   ],
73 |   // 默认使用百度搜索
74 |   action: (options, terminal) => {
75 |     const { from = "baidu" } = options;
76 |     // 执行不同搜索源的搜索方法
77 |     const fromObj = fromDict[from];
78 |     if (!fromObj) {
79 |       terminal.writeTextErrorResult("找不到搜索源");
80 |       return;
81 |     }
82 |     return fromObj.action(options, terminal);
83 |   },
84 | };
85 | 
86 | export default [searchCommand, ...Object.values(fromDict)];
87 | 


--------------------------------------------------------------------------------
/src/core/commandRegister.ts:
--------------------------------------------------------------------------------
 1 | import { CommandType } from "./command";
 2 | import searchCommands from "./commands/search/searchCommands";
 3 | import gotoCommand from "./commands/gotoCommand";
 4 | import spaceCommands from "./commands/space/spaceCommands";
 5 | import dateCommand from "./commands/dateCommand";
 6 | import clearCommand from "./commands/terminal/clearCommand";
 7 | import historyCommand from "./commands/terminal/historyCommand";
 8 | import userCommands from "./commands/user/userCommands";
 9 | import timingCommand from "./commands/timing/timingCommand";
10 | import backgroundCommand from "./commands/terminal/config/backgroundCommand";
11 | import resetCommand from "./commands/terminal/config/resetCommand";
12 | import fanyiCommand from "./commands/fanyi/fanyiCommand";
13 | import helpCommand from "./commands/terminal/help/helpCommand";
14 | import infoCommand from "./commands/terminal/info/infoCommand";
15 | import pingCommand from "./commands/pingCommand";
16 | import hintCommand from "./commands/terminal/config/hintCommand";
17 | import todoCommand from "./commands/todo/todoCommand";
18 | import musicCommand from "./commands/relax/music/musicCommand";
19 | import ddosCommand from "./commands/ddos/ddosCommand";
20 | import moyuCommand from "./commands/relax/moyu/moyuCommand";
21 | import shortcutCommand from "./commands/terminal/shortcut/shortcutCommand";
22 | import ikunCommand from "./commands/relax/ikun/ikunCommand";
23 | import welcomeCommand from "./commands/terminal/config/welcomeCommand";
24 | import hotCommand from "./commands/hot/hotCommand";
25 | import ikuntestCommand from "./commands/relax/ikuntest/ikuntestCommand";
26 | import varbookCommand from "./commands/varbook/varbookCommand";
27 | 
28 | /**
29 |  * 命令列表（数组元素顺序会影响 help 命令的展示顺序）
30 |  */
31 | const commandList: CommandType[] = [
32 |   shortcutCommand,
33 |   gotoCommand,
34 |   ...searchCommands,
35 |   ...spaceCommands,
36 |   ...userCommands,
37 |   varbookCommand,
38 |   hotCommand,
39 |   todoCommand,
40 |   timingCommand,
41 |   dateCommand,
42 |   clearCommand,
43 |   historyCommand,
44 |   fanyiCommand,
45 |   helpCommand,
46 |   infoCommand,
47 |   pingCommand,
48 |   musicCommand,
49 |   ddosCommand,
50 |   moyuCommand,
51 |   ikunCommand,
52 |   ikuntestCommand,
53 |   welcomeCommand,
54 |   backgroundCommand,
55 |   resetCommand,
56 |   hintCommand,
57 | ];
58 | 
59 | /**
60 |  * 命令字典
61 |  */
62 | const commandMap: Record<string, CommandType> = {};
63 | 
64 | commandList.forEach((command) => {
65 |   commandMap[command.func] = command;
66 |   command.alias?.forEach((name) => {
67 |     commandMap[name] = command;
68 |   });
69 | });
70 | 
71 | export { commandList, commandMap };
72 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/shortcuts.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * 快捷键系统
  3 |  * @author yupi
  4 |  */
  5 | import TerminalType = YuTerminal.TerminalType;
  6 | 
  7 | /**
  8 |  * 注册快捷键
  9 |  * @param terminal
 10 |  */
 11 | export const registerShortcuts = (terminal: TerminalType) => {
 12 |   document.onkeydown = (e) => {
 13 |     // console.log(e);
 14 |     let key = e.key;
 15 |     // 自动聚焦输入框
 16 |     if (key >= "a" && key <= "z" && !e.metaKey && !e.shiftKey && !e.ctrlKey) {
 17 |       terminal.focusInput();
 18 |       return;
 19 |     }
 20 |     // 匹配快捷键
 21 |     let code = e.code;
 22 |     for (const shortcut of shortcutList) {
 23 |       if (
 24 |         code === shortcut.code &&
 25 |         e.ctrlKey == !!shortcut.ctrlKey &&
 26 |         e.metaKey == !!shortcut.metaKey &&
 27 |         e.shiftKey == !!shortcut.shiftKey
 28 |       ) {
 29 |         shortcut.action(e, terminal);
 30 |       }
 31 |     }
 32 |   };
 33 | };
 34 | 
 35 | /**
 36 |  * 快捷键类型
 37 |  */
 38 | interface ShortcutType {
 39 |   code: string; // 按键码
 40 |   desc?: string; // 功能描述
 41 |   keyDesc?: string; // 按键描述
 42 |   ctrlKey?: boolean;
 43 |   metaKey?: boolean;
 44 |   shiftKey?: boolean;
 45 |   action: (e: Event, terminal: TerminalType) => void;
 46 | }
 47 | 
 48 | /**
 49 |  * 快捷键列表
 50 |  */
 51 | export const shortcutList: ShortcutType[] = [
 52 |   {
 53 |     desc: "清屏",
 54 |     code: "KeyL",
 55 |     keyDesc: "Ctrl + L",
 56 |     ctrlKey: true,
 57 |     action(e, terminal) {
 58 |       e.preventDefault();
 59 |       terminal.clear();
 60 |     },
 61 |   },
 62 |   {
 63 |     desc: "折叠",
 64 |     code: "KeyO",
 65 |     keyDesc: "Ctrl + O",
 66 |     ctrlKey: true,
 67 |     action(e, terminal) {
 68 |       e.preventDefault();
 69 |       terminal.toggleAllCollapse();
 70 |     },
 71 |   },
 72 |   {
 73 |     desc: "粘贴",
 74 |     code: "KeyV",
 75 |     keyDesc: "Ctrl + V",
 76 |     metaKey: true,
 77 |     action(e, terminal) {
 78 |       terminal.focusInput();
 79 |     },
 80 |   },
 81 |   {
 82 |     code: "Tab",
 83 |     action(e, terminal) {
 84 |       e.preventDefault();
 85 |       if (terminal.isInputFocused()) {
 86 |         terminal.setTabCompletion();
 87 |       } else {
 88 |         terminal.focusInput();
 89 |       }
 90 |     },
 91 |   },
 92 |   {
 93 |     code: "Backspace",
 94 |     action(e, terminal) {
 95 |       terminal.focusInput();
 96 |     },
 97 |   },
 98 |   {
 99 |     code: "Enter",
100 |     action(e, terminal) {
101 |       terminal.focusInput();
102 |     },
103 |   },
104 |   {
105 |     desc: "查看上一条命令",
106 |     code: "ArrowUp",
107 |     keyDesc: "↑",
108 |     action(e, terminal) {
109 |       e.preventDefault();
110 |       terminal.showPrevCommand();
111 |     },
112 |   },
113 |   {
114 |     desc: "查看下一条命令",
115 |     code: "ArrowDown",
116 |     keyDesc: "↓",
117 |     action(e, terminal) {
118 |       e.preventDefault();
119 |       terminal.showNextCommand();
120 |     },
121 |   },
122 | ];
123 | 


--------------------------------------------------------------------------------
/src/pages/old/XTermPage.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div ref="domRef" style="height: 100vh" />
  3 | </template>
  4 | <!-- 已过时，XTerm 不好用 -->
  5 | <script setup lang="ts">
  6 | import { Terminal } from "xterm";
  7 | import { onBeforeUnmount, onMounted, ref } from "vue";
  8 | import { FitAddon } from "xterm-addon-fit";
  9 | import { WebLinksAddon } from "xterm-addon-web-links";
 10 | import { doCommandExecute } from "../../core/commandExecutor";
 11 | import "xterm/css/xterm.css";
 12 | 
 13 | const domRef = ref();
 14 | let term: any;
 15 | const userName = ref("local");
 16 | let currentLine = "";
 17 | 
 18 | onMounted(() => {
 19 |   initXTerm();
 20 | });
 21 | 
 22 | /**
 23 |  * 初始化终端
 24 |  */
 25 | const initXTerm = () => {
 26 |   term = new Terminal({
 27 |     disableStdin: false, // 禁用输入
 28 |     cursorBlink: true, //光标闪烁
 29 |     tabStopWidth: 4, // tab 对应的空格数
 30 |     fontSize: 18,
 31 |   });
 32 |   const fitAddon: FitAddon = new FitAddon(); // 全屏插件
 33 |   term.loadAddon(fitAddon);
 34 |   term.loadAddon(new WebLinksAddon());
 35 |   term.open(domRef.value);
 36 |   fitAddon.fit();
 37 |   term.focus();
 38 | 
 39 |   const promptWords = `\r\n[${userName.value}]$ `;
 40 | 
 41 |   term.prompt = () => {
 42 |     term.write(promptWords);
 43 |   };
 44 | 
 45 |   term.writeln("Welcome to YuIndex，coolest browser index for geeks!");
 46 |   term.writeln("Author coder_yupi: https://github.com/liyupi");
 47 |   term.prompt();
 48 | 
 49 |   term.onData((key: string) => {
 50 |     if (key.match(/[\u4E00-\u9FA5]/)) {
 51 |       currentLine += key;
 52 |       term.write(new TextEncoder().encode(key));
 53 |     }
 54 |   });
 55 | 
 56 |   term.onKey((e: any) => {
 57 |     const ev = e.domEvent;
 58 |     const printable =
 59 |       !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey;
 60 |     // 回车
 61 |     if (ev.keyCode === 13) {
 62 |       // 执行命令
 63 |       term.writeln("");
 64 |       doCommandExecute(currentLine, term);
 65 |       currentLine = "";
 66 |       term.prompt();
 67 |     } else if (ev.keyCode === 8) {
 68 |       // 防止删除提示符
 69 |       if (term._core.buffer.x > promptWords.length - 2) {
 70 |         currentLine = currentLine.slice(0, -1);
 71 |         term.write("\b \b");
 72 |       }
 73 |     } else if (printable) {
 74 |       currentLine += e.key;
 75 |       term.write(e.key);
 76 |     }
 77 |   });
 78 | 
 79 |   // // 处理粘贴事件，可以不用获取权限
 80 |   // term.textarea.addEventListener("paste", (e: ClipboardEvent) => {
 81 |   //   const pasteWords = e.clipboardData?.getData("text");
 82 |   //   currentLine += pasteWords;
 83 |   //   term.write(pasteWords);
 84 |   // });
 85 | 
 86 |   window.onresize = () => fitAddon.fit();
 87 | 
 88 |   // 自定义快捷键
 89 |   term.attachCustomKeyEventHandler((e: any) => {
 90 |     // 清屏
 91 |     if (e.ctrlKey && e.code === "KeyL" && e.type === "keydown") {
 92 |       term.clear();
 93 |       return true;
 94 |     }
 95 |     return true;
 96 |   });
 97 | };
 98 | 
 99 | onBeforeUnmount(() => {
100 |   term?.dispose();
101 | });
102 | </script>
103 | 
104 | <style>
105 | .terminal {
106 |   height: calc(100% - 50px);
107 |   padding: 25px;
108 |   overflow: hidden;
109 | }
110 | </style>
111 | 


--------------------------------------------------------------------------------
/src/core/commands/relax/ikun/charVideo.js:
--------------------------------------------------------------------------------
  1 | // 视频转字符画类
  2 | 
  3 | // 默认配置
  4 | const defaultConfig = {
  5 |   space: 7, // 空间
  6 |   canvasElement: $("charVideoCanvas"), // 字符画画布
  7 |   width: 800,
  8 |   height: 450,
  9 | };
 10 | 
 11 | // constructor
 12 | function CharVideo(config = defaultConfig) {
 13 |   this.space = config.space || defaultConfig.space;
 14 |   this.width = Math.ceil(
 15 |     (defaultConfig.width ?? window.innerWidth) / this.space
 16 |   );
 17 |   this.height = Math.ceil(
 18 |     (defaultConfig.height ?? window.innerHeight) / this.space
 19 |   );
 20 |   this.data = {};
 21 |   this.cav = {};
 22 |   this.ctx = {};
 23 |   this.charVedio = config.canvasElement;
 24 |   this.charVedio.width = defaultConfig.width ?? window.innerWidth;
 25 |   this.charVedio.height = defaultConfig.height ?? window.innerHeight;
 26 |   this.textCtx = this.charVedio.getContext("2d");
 27 |   this.init();
 28 | }
 29 | 
 30 | // 初始化
 31 | CharVideo.prototype.init = function () {
 32 |   this.initVideo();
 33 |   this.initCanvas();
 34 | };
 35 | 
 36 | CharVideo.prototype.initVideo = function (src) {
 37 |   if (!this.video) {
 38 |     this.video = document.createElement("video");
 39 |   }
 40 |   if (src) {
 41 |     this.video.src = src;
 42 |   }
 43 | };
 44 | 
 45 | CharVideo.prototype.initCanvas = function () {
 46 |   this.cav = document.createElement("canvas");
 47 |   this.ctx = this.cav.getContext("2d");
 48 |   this.cav.width = this.width;
 49 |   this.cav.height = this.height;
 50 | };
 51 | 
 52 | CharVideo.prototype.loadData = function () {
 53 |   return this.ctx.getImageData(0, 0, this.width, this.height);
 54 | };
 55 | 
 56 | CharVideo.prototype.reDraw = function (data) {
 57 |   for (var i = 0, len = data.data.length; i < len; i += 4) {
 58 |     var r = data.data[i],
 59 |       g = data.data[i + 1],
 60 |       b = data.data[i + 2];
 61 |     data.data[i] =
 62 |       data.data[i + 1] =
 63 |       data.data[i + 2] =
 64 |         (255 - (r + g + b) / 3) | 0;
 65 |   }
 66 |   this.data = data;
 67 |   this.ctx.putImageData(data, 0, 0, 0, 0, this.width, this.height);
 68 | };
 69 | 
 70 | CharVideo.prototype.drawText = function () {
 71 |   this.textCtx.clearRect(0, 0, window.innerWidth, window.innerHeight);
 72 |   var data = this.data.data;
 73 |   var points = ' .,`"^:!?o+*wU$HB%@&#M'.split("");
 74 |   for (var i = 0, len = data.length; i < len; i += 4) {
 75 |     this.textCtx.fillStyle = "#333";
 76 |     var xl = ((i / 4) | 0) % this.width;
 77 |     var yl = Math.ceil(i / 4 / this.width);
 78 |     var x = xl * this.space;
 79 |     var y = yl * this.space;
 80 |     var newData = data[i] | 0;
 81 |     var plen = Math.ceil(255 / points.length);
 82 |     var point = points[(newData / plen) | 0];
 83 |     this.textCtx.font = "12px courier";
 84 |     this.textCtx.fillText(point, x, y);
 85 |   }
 86 | };
 87 | 
 88 | CharVideo.prototype.interval = function () {
 89 |   var that = this;
 90 |   requestAnimationFrame(function () {
 91 |     if (!that.video.paused) {
 92 |       that.ctx.drawImage(that.video, 0, 0, that.width, that.height);
 93 |       var data = that.loadData();
 94 |       that.reDraw(data);
 95 |       that.drawText();
 96 |     }
 97 |     that.interval();
 98 |   });
 99 | };
100 | 
101 | CharVideo.prototype.playFile = function (blob) {
102 |   this.src = URL.createObjectURL(blob);
103 |   this.initVideo(this.src);
104 |   this.interval();
105 |   this.video.play();
106 | };
107 | 
108 | function $(id) {
109 |   return document.getElementById(id);
110 | }
111 | 
112 | export default CharVideo;
113 | 


--------------------------------------------------------------------------------
/src/core/commandExecutor.ts:
--------------------------------------------------------------------------------
  1 | import getopts, { ParsedOptions } from "getopts";
  2 | import { commandMap } from "./commandRegister";
  3 | import { CommandOptionType, CommandType } from "./command";
  4 | import TerminalType = YuTerminal.TerminalType;
  5 | import helpCommand from "./commands/terminal/help/helpCommand";
  6 | 
  7 | /**
  8 |  * 执行命令
  9 |  * @param text 输入字符串
 10 |  * @param terminal 终端
 11 |  * @param parentCommand
 12 |  */
 13 | export const doCommandExecute = async (
 14 |   text: string,
 15 |   terminal: TerminalType,
 16 |   parentCommand?: CommandType
 17 | ) => {
 18 |   //去除命令首尾空格
 19 |   text = text.trim();
 20 |   if (!text) {
 21 |     return;
 22 |   }
 23 |   // 解析文本，得到命令
 24 |   const command: CommandType = getCommand(text, parentCommand);
 25 |   if (!command) {
 26 |     terminal.writeTextErrorResult("找不到命令");
 27 |     return;
 28 |   }
 29 |   // 解析参数（需传递不同的解析规则）
 30 |   const parsedOptions = doParse(text, command.options);
 31 |   const { _ } = parsedOptions;
 32 |   // 有子命令，执行
 33 |   if (
 34 |     _.length > 0 &&
 35 |     command.subCommands &&
 36 |     Object.keys(command.subCommands).length > 0
 37 |   ) {
 38 |     // 把子命令当做新命令解析，user login xxx => login xxx
 39 |     const subText = text.substring(text.indexOf(" ") + 1);
 40 |     await doCommandExecute(subText, terminal, command);
 41 |     return;
 42 |   }
 43 |   // 执行命令
 44 |   await doAction(command, parsedOptions, terminal, parentCommand);
 45 | };
 46 | 
 47 | /**
 48 |  * 获取命令（匹配）
 49 |  * @param text
 50 |  * @param parentCommand
 51 |  */
 52 | const getCommand = (text: string, parentCommand?: CommandType): CommandType => {
 53 |   let func = text.split(" ", 1)[0];
 54 |   // 大小写无关
 55 |   func = func.toLowerCase();
 56 |   let commands = commandMap;
 57 |   // 有父命令，则从父命令中查找
 58 |   if (
 59 |     parentCommand &&
 60 |     parentCommand.subCommands &&
 61 |     Object.keys(parentCommand.subCommands).length > 0
 62 |   ) {
 63 |     commands = parentCommand.subCommands;
 64 |   }
 65 |   const command = commands[func];
 66 |   console.log("getCommand = ", command);
 67 |   return command;
 68 | };
 69 | 
 70 | /**
 71 |  * 解析参数
 72 |  * @param text
 73 |  * @param commandOptions
 74 |  */
 75 | const doParse = (
 76 |   text: string,
 77 |   commandOptions: CommandOptionType[]
 78 | ): getopts.ParsedOptions => {
 79 |   // 过滤掉关键词
 80 |   const args: string[] = text.split(" ").slice(1);
 81 |   // 转换
 82 |   const options: getopts.Options = {
 83 |     alias: {},
 84 |     default: {},
 85 |     string: [],
 86 |     boolean: [],
 87 |   };
 88 |   commandOptions.forEach((commandOption) => {
 89 |     const { alias, key, type, defaultValue } = commandOption;
 90 |     if (alias && options.alias) {
 91 |       options.alias[key] = alias;
 92 |     }
 93 |     options[type]?.push(key);
 94 |     if (defaultValue && options.default) {
 95 |       options.default[key] = defaultValue;
 96 |     }
 97 |   });
 98 |   const parsedOptions = getopts(args, options);
 99 |   console.log("parsedOptions = ", parsedOptions);
100 |   return parsedOptions;
101 | };
102 | 
103 | /**
104 |  * 执行
105 |  * @param command
106 |  * @param options
107 |  * @param terminal
108 |  * @param parentCommand
109 |  */
110 | const doAction = async (
111 |   command: CommandType,
112 |   options: ParsedOptions,
113 |   terminal: TerminalType,
114 |   parentCommand?: CommandType
115 | ) => {
116 |   const { help } = options;
117 |   // 设置输出折叠
118 |   if (command.collapsible || help) {
119 |     terminal.setCommandCollapsible(true);
120 |   }
121 |   // 查看帮助
122 |   // e.g. xxx --help => { _: ["xxx"] }
123 |   if (help) {
124 |     const newOptions = { ...options, _: [command.func] };
125 |     helpCommand.action(newOptions, terminal, parentCommand);
126 |     return;
127 |   }
128 |   await command.action(options, terminal);
129 | };
130 | 


--------------------------------------------------------------------------------
/src/core/commands/space/spaceStore.ts:
--------------------------------------------------------------------------------
  1 | import { defineStore } from "pinia";
  2 | import { SpaceItemType, SpaceType } from "./spaceCommands";
  3 | 
  4 | /**
  5 |  * 空间状态（类似文件系统实现）
  6 |  */
  7 | export const useSpaceStore = defineStore("space", {
  8 |   state: () => ({
  9 |     // 空间
 10 |     space: {
 11 |       // 默认包含根目录
 12 |       "/": {
 13 |         name: "/",
 14 |         dir: "/",
 15 |         type: "dir",
 16 |       },
 17 |     } as SpaceType,
 18 |     // 当前所在目录
 19 |     currentDir: "/",
 20 |   }),
 21 |   getters: {},
 22 |   // 持久化
 23 |   persist: {
 24 |     key: "space-store",
 25 |     storage: window.localStorage,
 26 |     beforeRestore: (context) => {
 27 |       console.log("load spaceStore data start");
 28 |     },
 29 |     afterRestore: (context) => {
 30 |       console.log("load spaceStore data end");
 31 |     },
 32 |   },
 33 |   actions: {
 34 |     /**
 35 |      * 获取单条目
 36 |      * @param key
 37 |      */
 38 |     getItem(key: string) {
 39 |       const fullPath = getFullPath(this.currentDir, key);
 40 |       return this.space[fullPath];
 41 |     },
 42 |     /**
 43 |      * 获取某目录下的条目
 44 |      * @param dir 目录
 45 |      * @param recursive 是否递归
 46 |      */
 47 |     listItems(dir?: string, recursive = false): SpaceItemType[] {
 48 |       if (!dir) {
 49 |         dir = this.currentDir;
 50 |       } else {
 51 |         dir = getFullPath(this.currentDir, dir);
 52 |       }
 53 |       const resultList: SpaceItemType[] = [];
 54 |       // 父目录层级
 55 |       const parentDirDepth = getItemDepth(dir);
 56 |       // 查询 dir 下的 item
 57 |       for (const key in this.space) {
 58 |         // 不列举自身
 59 |         if (key === dir) {
 60 |           continue;
 61 |         }
 62 |         // 前缀必须匹配
 63 |         if (!key.startsWith(dir)) {
 64 |           continue;
 65 |         }
 66 |         // 不递归，只展示直接子级
 67 |         if (!recursive) {
 68 |           // 直接子级的 '/' 数比父级多 1
 69 |           if (getItemDepth(key) - 1 === parentDirDepth) {
 70 |             resultList.push(this.space[key]);
 71 |           }
 72 |         } else {
 73 |           resultList.push(this.space[key]);
 74 |         }
 75 |       }
 76 |       return resultList;
 77 |     },
 78 |     /**
 79 |      * 添加条目
 80 |      * @param item
 81 |      */
 82 |     addItem(item: SpaceItemType) {
 83 |       const fullPath = getFullPath(item.dir, item.name);
 84 |       // 目录不存在
 85 |       if (!this.space[item.dir]) {
 86 |         return false;
 87 |       }
 88 |       // 文件已存在 todo 支持覆盖
 89 |       if (this.space[fullPath]) {
 90 |         return false;
 91 |       }
 92 |       this.space[fullPath] = item;
 93 |       return true;
 94 |     },
 95 |     /**
 96 |      * 删除条目
 97 |      * @param key
 98 |      * @param recursive
 99 |      */
100 |     deleteItem(key: string, recursive = false) {
101 |       const fullPath = getFullPath(this.currentDir, key);
102 |       // 目录不存在
103 |       if (!this.space[fullPath]) {
104 |         return false;
105 |       }
106 |       const deleteKeyList = [fullPath];
107 |       // 需要递归删除
108 |       if (recursive) {
109 |         for (const spaceKey in this.space) {
110 |           if (spaceKey.startsWith(fullPath)) {
111 |             deleteKeyList.push(spaceKey);
112 |           }
113 |         }
114 |       }
115 |       // 移除属性
116 |       deleteKeyList.forEach((deleteKey) => {
117 |         delete this.space[deleteKey];
118 |       });
119 |       return true;
120 |     },
121 |     /**
122 |      * 复制条目
123 |      * @param source
124 |      * @param target
125 |      * @param recursive
126 |      */
127 |     copyItem(source: string, target: string, recursive = false) {
128 |       // e.g. /a/b => /a/c
129 |       const sourceFullPath = getFullPath(this.currentDir, source);
130 |       const targetFullPath = getFullPath(this.currentDir, target);
131 |       // 源条目不存在
132 |       const sourceItem = this.space[sourceFullPath];
133 |       if (!sourceItem) {
134 |         return false;
135 |       }
136 |       // 复制目录必须开启递归
137 |       if (sourceItem.type === "dir" && !recursive) {
138 |         return false;
139 |       }
140 |       // todo 待实现递归
141 |       // 目标条目已存在
142 |       if (this.space[targetFullPath]) {
143 |         return false;
144 |       }
145 |       // 目标目录不存在
146 |       const targetParentDir = getParentDir(targetFullPath);
147 |       if (!this.space[targetParentDir]) {
148 |         return false;
149 |       }
150 |       const targetItem = { ...sourceItem };
151 |       targetItem.dir = targetParentDir;
152 |       targetItem.name = getItemName(targetFullPath);
153 |       return this.addItem(targetItem);
154 |     },
155 |     /**
156 |      * 移动条目（等同于复制 + 删除）
157 |      * @param source
158 |      * @param target
159 |      * @param recursive
160 |      */
161 |     moveItem(source: string, target: string, recursive = false) {
162 |       let result = this.copyItem(source, target, recursive);
163 |       if (result) {
164 |         result = this.deleteItem(source, recursive);
165 |       }
166 |       return result;
167 |     },
168 |     /**
169 |      * 更新当前所在目录
170 |      * @param newDir
171 |      */
172 |     updateCurrentDir(newDir: string) {
173 |       let fullPath = getFullPath(this.currentDir, newDir);
174 |       // 上层目录
175 |       if (newDir === "..") {
176 |         // 已经是根目录，无法到上层
177 |         if (this.currentDir === "/") {
178 |           return false;
179 |         } else {
180 |           fullPath = getParentDir(this.currentDir);
181 |         }
182 |       }
183 |       // 目录不存在
184 |       if (!this.space[fullPath]) {
185 |         return false;
186 |       }
187 |       this.currentDir = fullPath;
188 |       return true;
189 |     },
190 |   },
191 | });
192 | 
193 | /**
194 |  * 获得条目全路径
195 |  * @param dir 目录
196 |  * @param name 条目名称（位置）
197 |  */
198 | const getFullPath = (dir: string, name: string): string => {
199 |   if (name.startsWith("/")) {
200 |     return name;
201 |   }
202 |   return dir + (dir === "/" ? "" : "/") + name;
203 | };
204 | 
205 | /**
206 |  * 获取上层路径
207 |  * @param path
208 |  */
209 | const getParentDir = (path: string): string => {
210 |   let parentDir = "/";
211 |   if (path === "/") {
212 |     return parentDir;
213 |   }
214 |   // 切割掉最后一个 '/'
215 |   // e.g. /a/b => /a
216 |   parentDir = path.substring(0, path.lastIndexOf("/"));
217 |   // 有可能回退到根目录
218 |   // e.g. /a => ''（空字符串）
219 |   if (!parentDir) {
220 |     return "/";
221 |   }
222 |   return parentDir;
223 | };
224 | 
225 | /**
226 |  * 根据路径获取空间条目名
227 |  * @param path
228 |  */
229 | const getItemName = (path: string): string => {
230 |   if (path === "/") {
231 |     return path;
232 |   }
233 |   // 从最后一个 '/' 开始取字符串
234 |   // e.g. /a/b => b
235 |   return path.substring(path.lastIndexOf("/") + 1);
236 | };
237 | 
238 | /**
239 |  * 获得条目层级
240 |  * @param key
241 |  */
242 | const getItemDepth = (key: string) => {
243 |   if (key === "/") {
244 |     return 1;
245 |   }
246 |   return key.split("/").length;
247 | };
248 | 


--------------------------------------------------------------------------------
/src/components/yu-terminal/YuTerminal.vue:
--------------------------------------------------------------------------------
  1 | <template>
  2 |   <div
  3 |     class="yu-terminal-wrapper"
  4 |     :style="wrapperStyle"
  5 |     @click="handleClickWrapper"
  6 |   >
  7 |     <div ref="terminalRef" class="yu-terminal" :style="mainStyle">
  8 |       <a-collapse
  9 |         v-model:activeKey="activeKeys"
 10 |         :bordered="false"
 11 |         expand-icon-position="right"
 12 |       >
 13 |         <template v-for="(output, index) in outputList" :key="index">
 14 |           <!-- 折叠 -->
 15 |           <a-collapse-panel
 16 |             v-if="output.collapsible"
 17 |             :key="index"
 18 |             class="terminal-row"
 19 |           >
 20 |             <template #header>
 21 |               <span style="user-select: none; margin-right: 10px">
 22 |                 {{ prompt }}
 23 |               </span>
 24 |               <span>{{ output.text }}</span>
 25 |             </template>
 26 |             <div
 27 |               v-for="(result, idx) in output.resultList"
 28 |               :key="idx"
 29 |               class="terminal-row"
 30 |             >
 31 |               <content-output :output="result" />
 32 |             </div>
 33 |           </a-collapse-panel>
 34 |           <!-- 不折叠 -->
 35 |           <template v-else>
 36 |             <!-- 输出命令及结果-->
 37 |             <template v-if="output.type === 'command'">
 38 |               <div class="terminal-row">
 39 |                 <span style="user-select: none; margin-right: 10px">{{
 40 |                   prompt
 41 |                 }}</span>
 42 |                 <span>{{ output.text }}</span>
 43 |               </div>
 44 |               <div
 45 |                 v-for="(result, idx) in output?.resultList"
 46 |                 :key="idx"
 47 |                 class="terminal-row"
 48 |               >
 49 |                 <content-output :output="result" />
 50 |               </div>
 51 |             </template>
 52 |             <!-- 打印信息 -->
 53 |             <template v-else>
 54 |               <div class="terminal-row">
 55 |                 <content-output :output="output" />
 56 |               </div>
 57 |             </template>
 58 |           </template>
 59 |         </template>
 60 |       </a-collapse>
 61 |       <div class="terminal-row">
 62 |         <a-input
 63 |           ref="commandInputRef"
 64 |           v-model:value="inputCommand.text"
 65 |           :disabled="isRunning"
 66 |           class="command-input"
 67 |           :placeholder="inputCommand.placeholder"
 68 |           :bordered="false"
 69 |           autofocus
 70 |           @press-enter="doSubmitCommand"
 71 |         >
 72 |           <template #addonBefore>
 73 |             <span class="command-input-prompt">{{ prompt }}</span>
 74 |           </template>
 75 |         </a-input>
 76 |       </div>
 77 |       <!-- 输入提示-->
 78 |       <div v-if="hint && !isRunning" class="terminal-row" style="color: #bbb">
 79 |         hint：{{ hint }}
 80 |       </div>
 81 |       <div style="margin-bottom: 16px" />
 82 |     </div>
 83 |   </div>
 84 | </template>
 85 | 
 86 | <script setup lang="ts">
 87 | import {
 88 |   computed,
 89 |   onMounted,
 90 |   Ref,
 91 |   ref,
 92 |   StyleValue,
 93 |   toRefs,
 94 |   watchEffect,
 95 | } from "vue";
 96 | import CommandOutputType = YuTerminal.CommandOutputType;
 97 | import OutputType = YuTerminal.OutputType;
 98 | import CommandInputType = YuTerminal.CommandInputType;
 99 | import { registerShortcuts } from "./shortcuts";
100 | import TerminalType = YuTerminal.TerminalType;
101 | import TextOutputType = YuTerminal.TextOutputType;
102 | import useHistory from "./history";
103 | import ContentOutput from "./ContentOutput.vue";
104 | import OutputStatusType = YuTerminal.OutputStatusType;
105 | import { useTerminalConfigStore } from "../../core/commands/terminal/config/terminalConfigStore";
106 | import useHint from "./hint";
107 | import UserType = User.UserType;
108 | import { LOCAL_USER } from "../../core/commands/user/userConstant";
109 | import { defineStore } from "pinia";
110 | 
111 | interface YuTerminalProps {
112 |   height?: string | number;
113 |   fullScreen?: boolean;
114 |   user?: UserType;
115 |   // eslint-disable-next-line vue/require-default-prop
116 |   onSubmitCommand?: (inputText: string) => void;
117 | }
118 | 
119 | const props = withDefaults(defineProps<YuTerminalProps>(), {
120 |   height: "400px",
121 |   fullScreen: false,
122 |   user: LOCAL_USER as any,
123 | });
124 | 
125 | const { user } = toRefs(props);
126 | 
127 | const terminalRef = ref();
128 | const activeKeys = ref<number[]>([]);
129 | // 输出列表
130 | const outputList = ref<OutputType[]>([]);
131 | // 命令列表
132 | const commandList = ref<CommandOutputType[]>([]);
133 | const commandInputRef = ref();
134 | 
135 | // 命令是否运行
136 | const isRunning = ref(false);
137 | 
138 | // 引入终端配置状态
139 | const configStore = useTerminalConfigStore();
140 | 
141 | /**
142 |  * 初始命令
143 |  */
144 | const initCommand: CommandInputType = {
145 |   text: "",
146 |   placeholder: "",
147 | };
148 | 
149 | /**
150 |  * 待输入的命令
151 |  */
152 | const inputCommand = ref<CommandInputType>({
153 |   ...initCommand,
154 | });
155 | 
156 | /**
157 |  * 全局记录当前命令，便于写入结果
158 |  */
159 | let currentNewCommand: CommandOutputType;
160 | 
161 | const {
162 |   commandHistoryPos,
163 |   showPrevCommand,
164 |   showNextCommand,
165 |   listCommandHistory,
166 | } = useHistory(commandList.value, inputCommand);
167 | 
168 | const { hint, setHint, debounceSetHint } = useHint();
169 | 
170 | /**
171 |  * 提交命令（回车）
172 |  */
173 | const doSubmitCommand = async () => {
174 |   isRunning.value = true;
175 |   setHint("");
176 |   let inputText = inputCommand.value.text;
177 |   // 执行某条历史命令
178 |   if (inputText.startsWith("!")) {
179 |     const commandIndex = Number(inputText.substring(1));
180 |     const command = commandList.value[commandIndex - 1];
181 |     if (command) {
182 |       inputText = command.text;
183 |     }
184 |   }
185 |   // 执行命令
186 |   const newCommand: CommandOutputType = {
187 |     text: inputText,
188 |     type: "command",
189 |     resultList: [],
190 |   };
191 |   // 记录当前命令，便于写入结果
192 |   currentNewCommand = newCommand;
193 |   // 执行命令
194 |   await props.onSubmitCommand?.(inputText);
195 |   // 添加输出（为空也要输出换行）
196 |   outputList.value.push(newCommand);
197 |   // 不为空字符串才算是有效命令
198 |   if (inputText) {
199 |     commandList.value.push(newCommand);
200 |     // 重置当前要查看的命令位置
201 |     commandHistoryPos.value = commandList.value.length;
202 |   }
203 |   inputCommand.value = { ...initCommand };
204 |   // 默认展开折叠面板
205 |   activeKeys.value.push(outputList.value.length - 1);
206 |   // 自动滚到底部
207 |   setTimeout(() => {
208 |     terminalRef.value.scrollTop = terminalRef.value.scrollHeight;
209 |   }, 50);
210 |   isRunning.value = false;
211 | };
212 | 
213 | // 输入框内容改变时，触发输入提示
214 | watchEffect(() => {
215 |   debounceSetHint(inputCommand.value.text);
216 | });
217 | 
218 | /**
219 |  * 输入提示符
220 |  */
221 | const prompt = computed(() => {
222 |   return `[${user.value.username}]$`;
223 | });
224 | 
225 | /**
226 |  * 终端主样式
227 |  */
228 | const mainStyle = computed(() => {
229 |   const fullScreenStyle: StyleValue = {
230 |     position: "fixed",
231 |     top: 0,
232 |     bottom: 0,
233 |     left: 0,
234 |     right: 0,
235 |   };
236 |   return props.fullScreen
237 |     ? fullScreenStyle
238 |     : {
239 |         height: props.height,
240 |       };
241 | });
242 | 
243 | /**
244 |  * 终端包装类主样式
245 |  */
246 | const wrapperStyle = computed(() => {
247 |   const { background } = configStore;
248 |   const style = {
249 |     ...mainStyle.value,
250 |   };
251 |   if (background.startsWith("http")) {
252 |     style.background = `url(${background})`;
253 |   } else {
254 |     style.background = background;
255 |   }
256 |   return style;
257 | });
258 | 
259 | /**
260 |  * 清空所有输出
261 |  */
262 | const clear = () => {
263 |   outputList.value = [];
264 | };
265 | 
266 | /**
267 |  * 写命令文本结果
268 |  * @param text
269 |  * @param status
270 |  */
271 | const writeTextResult = (text: string, status?: OutputStatusType) => {
272 |   const newOutput: TextOutputType = {
273 |     text,
274 |     type: "text",
275 |     status,
276 |   };
277 |   currentNewCommand.resultList.push(newOutput);
278 | };
279 | 
280 | /**
281 |  * 写文本错误状态结果
282 |  * @param text
283 |  */
284 | const writeTextErrorResult = (text: string) => {
285 |   writeTextResult(text, "error");
286 | };
287 | 
288 | /**
289 |  * 写文本成功状态结果
290 |  * @param text
291 |  */
292 | const writeTextSuccessResult = (text: string) => {
293 |   writeTextResult(text, "success");
294 | };
295 | 
296 | /**
297 |  * 写结果
298 |  * @param output
299 |  */
300 | const writeResult = (output: OutputType) => {
301 |   currentNewCommand.resultList.push(output);
302 | };
303 | 
304 | /**
305 |  * 立即输出文本
306 |  * @param text
307 |  * @param status
308 |  */
309 | const writeTextOutput = (text: string, status?: OutputStatusType) => {
310 |   const newOutput: TextOutputType = {
311 |     text,
312 |     type: "text",
313 |     status,
314 |   };
315 |   outputList.value.push(newOutput);
316 | };
317 | 
318 | /**
319 |  * 设置命令是否可折叠
320 |  * @param collapsible
321 |  */
322 | const setCommandCollapsible = (collapsible: boolean) => {
323 |   currentNewCommand.collapsible = collapsible;
324 | };
325 | 
326 | /**
327 |  * 立即输出
328 |  * @param newOutput
329 |  */
330 | const writeOutput = (newOutput: OutputType) => {
331 |   outputList.value.push(newOutput);
332 | };
333 | 
334 | /**
335 |  * 输入框聚焦
336 |  */
337 | const focusInput = () => {
338 |   commandInputRef.value.focus();
339 | };
340 | /**
341 |  * 获取输入框是否聚焦
342 |  */
343 | const isInputFocused = () => {
344 |   return (
345 |     (commandInputRef.value.input as HTMLInputElement) == document.activeElement
346 |   );
347 | };
348 | /**
349 |  * 设置输入框的值
350 |  */
351 | const setTabCompletion = () => {
352 |   if (hint.value) {
353 |     inputCommand.value.text = `${hint.value.split(" ")[0]}${
354 |       hint.value.split(" ").length > 1 ? " " : ""
355 |     }`;
356 |   }
357 | };
358 | 
359 | /**
360 |  * 折叠 / 展开所有块
361 |  */
362 | const toggleAllCollapse = () => {
363 |   // 展开
364 |   if (activeKeys.value.length === 0) {
365 |     activeKeys.value = outputList.value.map((_, index) => {
366 |       return index;
367 |     });
368 |   } else {
369 |     // 折叠
370 |     activeKeys.value = [];
371 |   }
372 | };
373 | 
374 | /**
375 |  * 操作终端的对象
376 |  */
377 | const terminal: TerminalType = {
378 |   writeTextResult,
379 |   writeTextErrorResult,
380 |   writeTextSuccessResult,
381 |   writeResult,
382 |   writeTextOutput,
383 |   writeOutput,
384 |   clear,
385 |   focusInput,
386 |   isInputFocused,
387 |   setTabCompletion,
388 |   doSubmitCommand,
389 |   showNextCommand,
390 |   showPrevCommand,
391 |   listCommandHistory,
392 |   toggleAllCollapse,
393 |   setCommandCollapsible,
394 | };
395 | 
396 | /**
397 |  * 只执行一次
398 |  */
399 | onMounted(() => {
400 |   registerShortcuts(terminal);
401 |   const { welcomeTexts } = configStore;
402 |   if (welcomeTexts?.length > 0) {
403 |     welcomeTexts.forEach((welcomeText) => {
404 |       terminal.writeTextOutput(welcomeText);
405 |     });
406 |   } else {
407 |     terminal.writeTextOutput(
408 |       `Welcome to YuIndex, coolest browser index for geeks!` +
409 |         `<a href="//github.com/liyupi/yuindex" target='_blank'> GitHub Open Source</a>`
410 |     );
411 |     terminal.writeTextOutput(
412 |       `Author <a href="//docs.qq.com/doc/DUFFRVWladXVjeUxW" target="_blank">coder_yupi</a>` +
413 |         `: please input 'help' to enjoy`
414 |     );
415 |     terminal.writeTextOutput("<br/>");
416 |   }
417 | });
418 | 
419 | /**
420 |  * 当点击空白聚焦输入框
421 |  */
422 | function handleClickWrapper(event: Event): void {
423 |   //@ts-ignore
424 |   if (event.target.className === "yu-terminal") {
425 |     focusInput();
426 |   }
427 | }
428 | 
429 | defineExpose({
430 |   terminal,
431 | });
432 | </script>
433 | 
434 | <style scoped>
435 | .yu-terminal-wrapper {
436 |   background: black;
437 | }
438 | 
439 | .yu-terminal {
440 |   background: rgba(0, 0, 0, 0.6);
441 |   padding: 20px;
442 |   overflow: scroll;
443 | }
444 | 
445 | .yu-terminal::-webkit-scrollbar {
446 |   display: none;
447 | }
448 | 
449 | .yu-terminal span {
450 |   font-size: 16px;
451 | }
452 | 
453 | .yu-terminal
454 |   :deep(.ant-collapse-icon-position-right
455 |     > .ant-collapse-item
456 |     > .ant-collapse-header) {
457 |   color: white;
458 |   padding: 0;
459 | }
460 | 
461 | .yu-terminal :deep(.ant-collapse) {
462 |   background: none;
463 | }
464 | 
465 | .yu-terminal :deep(.ant-collapse-borderless > .ant-collapse-item) {
466 |   border: none;
467 | }
468 | 
469 | .yu-terminal :deep(.ant-collapse-content > .ant-collapse-content-box) {
470 |   padding: 0;
471 | }
472 | 
473 | .command-input {
474 |   caret-color: white;
475 | }
476 | 
477 | .command-input :deep(input) {
478 |   color: white !important;
479 |   font-size: 16px;
480 |   padding: 0 10px;
481 | }
482 | 
483 | .command-input :deep(.ant-input-group-addon) {
484 |   background: none;
485 |   border: none;
486 |   padding: 0;
487 | }
488 | 
489 | .command-input-prompt {
490 |   color: white;
491 |   background: transparent;
492 | }
493 | 
494 | .terminal-row {
495 |   color: white;
496 |   font-size: 16px;
497 |   font-family: courier-new, courier, monospace;
498 | }
499 | </style>
500 | 


--------------------------------------------------------------------------------