();
27 | const appInfoPromise = window.electron.ipcRenderer
28 | .getAppInfo()
29 | .then((resp) => setAppInfo(resp));
30 |
31 | return (
32 |
33 |
146 |
147 | );
148 | };
149 |
150 | export default Settings;
151 |
--------------------------------------------------------------------------------
/.erb/configs/webpack.config.renderer.dev.ts:
--------------------------------------------------------------------------------
1 | import 'webpack-dev-server';
2 | import path from 'path';
3 | import fs from 'fs';
4 | import webpack from 'webpack';
5 | import HtmlWebpackPlugin from 'html-webpack-plugin';
6 | import chalk from 'chalk';
7 | import { merge } from 'webpack-merge';
8 | import { execSync, spawn } from 'child_process';
9 | import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin';
10 | import baseConfig from './webpack.config.base';
11 | import webpackPaths from './webpack.paths';
12 | import checkNodeEnv from '../scripts/check-node-env';
13 |
14 | // When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
15 | // at the dev webpack config is not accidentally run in a production environment
16 | if (process.env.NODE_ENV === 'production') {
17 | checkNodeEnv('development');
18 | }
19 |
20 | const port = process.env.PORT || 1212;
21 | const manifest = path.resolve(webpackPaths.dllPath, 'renderer.json');
22 | const skipDLLs =
23 | module.parent?.filename.includes('webpack.config.renderer.dev.dll') ||
24 | module.parent?.filename.includes('webpack.config.eslint');
25 |
26 | /**
27 | * Warn if the DLL is not built
28 | */
29 | if (
30 | !skipDLLs &&
31 | !(fs.existsSync(webpackPaths.dllPath) && fs.existsSync(manifest))
32 | ) {
33 | console.log(
34 | chalk.black.bgYellow.bold(
35 | 'The DLL files are missing. Sit back while we build them for you with "npm run build-dll"'
36 | )
37 | );
38 | execSync('npm run postinstall');
39 | }
40 |
41 | const configuration: webpack.Configuration = {
42 | devtool: 'inline-source-map',
43 |
44 | mode: 'development',
45 |
46 | target: ['web', 'electron-renderer'],
47 |
48 | entry: [
49 | `webpack-dev-server/client?http://localhost:${port}/dist`,
50 | 'webpack/hot/only-dev-server',
51 | path.join(webpackPaths.srcRendererPath, 'index.tsx'),
52 | ],
53 |
54 | output: {
55 | path: webpackPaths.distRendererPath,
56 | publicPath: '/',
57 | filename: 'renderer.dev.js',
58 | library: {
59 | type: 'umd',
60 | },
61 | },
62 |
63 | module: {
64 | rules: [
65 | {
66 | test: /\.s?(c|a)ss$/,
67 | use: [
68 | 'style-loader',
69 | {
70 | loader: 'css-loader',
71 | options: {
72 | modules: true,
73 | sourceMap: true,
74 | importLoaders: 1,
75 | },
76 | },
77 | 'sass-loader',
78 | ],
79 | include: /\.module\.s?(c|a)ss$/,
80 | },
81 | {
82 | test: /\.s?css$/,
83 | use: ['style-loader', 'css-loader', 'sass-loader'],
84 | exclude: /\.module\.s?(c|a)ss$/,
85 | },
86 | // Fonts
87 | {
88 | test: /\.(woff|woff2|eot|ttf|otf)$/i,
89 | type: 'asset/resource',
90 | },
91 | // Images
92 | {
93 | test: /\.(png|jpg|jpeg|gif)$/i,
94 | type: 'asset/resource',
95 | },
96 | // SVG
97 | {
98 | test: /\.svg$/,
99 | use: [
100 | {
101 | loader: '@svgr/webpack',
102 | options: {
103 | prettier: false,
104 | svgo: false,
105 | svgoConfig: {
106 | plugins: [{ removeViewBox: false }],
107 | },
108 | titleProp: true,
109 | ref: true,
110 | },
111 | },
112 | 'file-loader',
113 | ],
114 | },
115 | ],
116 | },
117 | plugins: [
118 | ...(skipDLLs
119 | ? []
120 | : [
121 | new webpack.DllReferencePlugin({
122 | context: webpackPaths.dllPath,
123 | manifest: require(manifest),
124 | sourceType: 'var',
125 | }),
126 | ]),
127 |
128 | new webpack.NoEmitOnErrorsPlugin(),
129 |
130 | /**
131 | * Create global constants which can be configured at compile time.
132 | *
133 | * Useful for allowing different behaviour between development builds and
134 | * release builds
135 | *
136 | * NODE_ENV should be production so that modules do not perform certain
137 | * development checks
138 | *
139 | * By default, use 'development' as NODE_ENV. This can be overriden with
140 | * 'staging', for example, by changing the ENV variables in the npm scripts
141 | */
142 | new webpack.EnvironmentPlugin({
143 | NODE_ENV: 'development',
144 | }),
145 |
146 | new webpack.LoaderOptionsPlugin({
147 | debug: true,
148 | }),
149 |
150 | new ReactRefreshWebpackPlugin(),
151 |
152 | new HtmlWebpackPlugin({
153 | filename: path.join('index.html'),
154 | template: path.join(webpackPaths.srcRendererPath, 'index.ejs'),
155 | minify: {
156 | collapseWhitespace: true,
157 | removeAttributeQuotes: true,
158 | removeComments: true,
159 | },
160 | isBrowser: false,
161 | env: process.env.NODE_ENV,
162 | isDevelopment: process.env.NODE_ENV !== 'production',
163 | nodeModules: webpackPaths.appNodeModulesPath,
164 | }),
165 | ],
166 |
167 | node: {
168 | __dirname: false,
169 | __filename: false,
170 | },
171 |
172 | devServer: {
173 | port,
174 | compress: true,
175 | hot: true,
176 | headers: { 'Access-Control-Allow-Origin': '*' },
177 | static: {
178 | publicPath: '/',
179 | },
180 | historyApiFallback: {
181 | verbose: true,
182 | },
183 | setupMiddlewares(middlewares) {
184 | console.log('Starting preload.js builder...');
185 | const preloadProcess = spawn('npm', ['run', 'start:preload'], {
186 | shell: true,
187 | stdio: 'inherit',
188 | })
189 | .on('close', (code: number) => process.exit(code!))
190 | .on('error', (spawnError) => console.error(spawnError));
191 |
192 | console.log('Starting Main Process...');
193 | let args = ['run', 'start:main'];
194 | if (process.env.MAIN_ARGS) {
195 | args = args.concat(
196 | ['--', ...process.env.MAIN_ARGS.matchAll(/"[^"]+"|[^\s"]+/g)].flat()
197 | );
198 | }
199 | spawn('npm', args, {
200 | shell: true,
201 | stdio: 'inherit',
202 | })
203 | .on('close', (code: number) => {
204 | preloadProcess.kill();
205 | process.exit(code!);
206 | })
207 | .on('error', (spawnError) => console.error(spawnError));
208 | return middlewares;
209 | },
210 | },
211 | };
212 |
213 | export default merge(baseConfig, configuration);
214 |
--------------------------------------------------------------------------------
/src/main/menuHandler.ts:
--------------------------------------------------------------------------------
1 | import { BrowserWindow, dialog } from 'electron';
2 | import fs from 'fs';
3 | import fsAsync from 'fs/promises';
4 | import path from 'path';
5 | import log from 'electron-log';
6 |
7 | import type { AssetDependence, Song, Songlist } from 'type';
8 | import { globalStore } from '../globalStore';
9 | import { importSong, makePackage, mergeSonglist } from './utils/assets';
10 | import { buildAssetsSongDepList } from './utils/songDeps';
11 |
12 | export function importSongMenuHandlerFactory(
13 | mainWindow: BrowserWindow,
14 | external = false
15 | ) {
16 | return async () => {
17 | const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
18 | properties: [
19 | 'openDirectory',
20 | 'treatPackageAsDirectory',
21 | 'multiSelections',
22 | ],
23 | });
24 | if (!canceled) {
25 | const songs: Song[] = [];
26 | const failedPaths: string[] = [];
27 | const assetsPath = globalStore.get('assets.path') as string;
28 | for (const srcPath of filePaths) {
29 | const imported = await importSong(srcPath, assetsPath);
30 | if (imported) {
31 | if (external) {
32 | imported._external = srcPath;
33 | }
34 | songs.push(imported);
35 | } else {
36 | failedPaths.push(srcPath);
37 | }
38 | }
39 | const mergedSongs = await mergeSonglist(
40 | songs,
41 | globalStore.get('assets.songs') as Song[]
42 | );
43 | globalStore.set('assets.songs', mergedSongs);
44 | fs.writeFileSync(
45 | path.join(assetsPath, 'songs', 'songlist'),
46 | JSON.stringify({ songs: mergedSongs }, null, 2)
47 | );
48 |
49 | dialog.showMessageBox({
50 | message: '\n'.concat(
51 | `已导入 ${songs.length} 首歌曲`,
52 | failedPaths.length === 0
53 | ? ''
54 | : `\n\n以下歌曲导入失败：\n${failedPaths.join('\n')}`
55 | ),
56 | type: failedPaths.length === 0 ? 'info' : 'error',
57 | });
58 | }
59 | };
60 | }
61 |
62 | export function importBgMenuHandlerFactory(mainWindow: BrowserWindow) {
63 | return async () => {
64 | const { canceled, filePaths } = await dialog.showOpenDialog(mainWindow, {
65 | properties: ['openFile', 'treatPackageAsDirectory', 'multiSelections'],
66 | filters: [{ name: '背景图片', extensions: ['jpg'] }],
67 | });
68 | if (!canceled) {
69 | const importedBgs = [];
70 | const failedPaths: string[] = [];
71 | const assetsPath = globalStore.get('assets.path') as string;
72 | const imgBgPath = path.join(assetsPath, 'img', 'bg');
73 | filePaths.forEach((srcBgPath) => {
74 | const destBgPath = path.join(imgBgPath, path.basename(srcBgPath));
75 | log.verbose(`${srcBgPath} -> ${destBgPath}`);
76 | try {
77 | fs.copyFileSync(srcBgPath, destBgPath);
78 | importedBgs.push(srcBgPath);
79 | } catch (e) {
80 | log.error(e);
81 | failedPaths.push(srcBgPath);
82 | }
83 | });
84 |
85 | dialog.showMessageBox({
86 | message: '\n'.concat(
87 | `已导入 ${importedBgs.length} 张背景`,
88 | failedPaths.length === 0
89 | ? ''
90 | : `\n\n以下背景导入失败：\n${failedPaths.join('\n')}`
91 | ),
92 | type: failedPaths.length === 0 ? 'info' : 'error',
93 | });
94 | }
95 | };
96 | }
97 |
98 | export function generatePackageMenuHandlerFactory(mainWindow: BrowserWindow) {
99 | return async () => {
100 | const { canceled, filePath } = await dialog.showSaveDialog(mainWindow, {
101 | title: '选择导出安装包格式与位置',
102 | filters: [
103 | { name: 'iOS Application', extensions: ['ipa'] },
104 | { name: 'Android Package', extensions: ['apk'] },
105 | ],
106 | properties: ['createDirectory'],
107 | });
108 | if (!canceled && filePath) {
109 | const savePath = filePath;
110 | const saveExt = path.extname(savePath);
111 |
112 | const assetsPath = globalStore.get('assets.path') as string;
113 | const packageRoot = path.resolve(
114 | assetsPath,
115 | saveExt === '.ipa' ? '../..' : '..'
116 | );
117 |
118 | const songs = globalStore.get('assets.songs') as Song[];
119 | const songCopyPromises = songs.map((song) => {
120 | if (song._external) {
121 | log.info(`外置依赖 ${song._external}`);
122 | return importSong(song._external, assetsPath);
123 | }
124 | return new Promise((resolve) => {
125 | resolve();
126 | });
127 | });
128 | const copyExtResult = await Promise.allSettled(songCopyPromises).catch(
129 | (e) => {
130 | dialog.showErrorBox('外部文件复制失败', e.message);
131 | }
132 | );
133 |
134 | if (
135 | copyExtResult &&
136 | copyExtResult.filter((r) => r.status === 'rejected').length < 1
137 | ) {
138 | const { response } = await dialog.showMessageBox(mainWindow, {
139 | message: `确定包路径为 ${packageRoot} 吗？`,
140 | type: 'question',
141 | buttons: ['好', '取消'],
142 | defaultId: 0,
143 | title: '确认包路径',
144 | detail:
145 | '这个文件夹应该包含所有需要被打包的文件。\n\n此外，强烈建议您在打包之前进行依赖验证。',
146 | cancelId: 1,
147 | });
148 | if (response === 0) {
149 | makePackage(packageRoot, savePath, mainWindow);
150 | }
151 | }
152 | }
153 | };
154 | }
155 |
156 | export function verifyMenuHandlerFactory(mainWindow: BrowserWindow) {
157 | return async () => {
158 | const assetsPath = globalStore.get('assets.path') as string;
159 | const songsPath = path.join(assetsPath, 'songs');
160 | const songlistPath = path.join(songsPath, 'songlist');
161 |
162 | const songlistFile = await fsAsync.readFile(songlistPath);
163 | const songlist = JSON.parse(songlistFile.toString()) as Songlist;
164 |
165 | const songlistDepPromises = songlist.songs.map((song) => {
166 | return buildAssetsSongDepList(song);
167 | });
168 |
169 | const songlistDeps = await Promise.all(songlistDepPromises);
170 | log.debug(songlistDeps);
171 | const flattenDeps = songlistDeps.flat();
172 |
173 | const errPath: AssetDependence[] = [];
174 | flattenDeps.forEach((dep) => {
175 | if (!fs.existsSync(path.join(assetsPath, dep.dep))) {
176 | errPath.push(dep);
177 | }
178 | });
179 |
180 | let dialogType = 'info';
181 | let errCount = 0;
182 | const errHints: string[] = [];
183 | errPath.forEach((err) => {
184 | if (err.dep.endsWith('3.aff')) {
185 | dialogType = 'warning';
186 | errHints.push(
187 | `[W] ${err.sourceID} 的Beyond难度已定义但是谱面不存在，可能需要在线加载。`
188 | );
189 | } else {
190 | dialogType = 'error';
191 | errCount += 1;
192 | errHints.unshift(`[E] ${err.sourceID} 需要 ${err.dep}，但是它不存在。`);
193 | }
194 | });
195 |
196 | dialog.showMessageBox(mainWindow, {
197 | message:
198 | errPath.length === 0
199 | ? '没有检测到依赖问题。'
200 | : `检测到以下问题，其中有 ${errCount} 个错误。`,
201 | detail: errHints.join('\n'),
202 | type: dialogType,
203 | });
204 | };
205 | }
206 |
--------------------------------------------------------------------------------
/src/main/utils/assets.ts:
--------------------------------------------------------------------------------
1 | import path from 'path';
2 | import fs from 'fs';
3 | import fsAsync from 'fs/promises';
4 | import log from 'electron-log';
5 | import archiver, { ProgressData } from 'archiver';
6 | import { app, BrowserWindow, dialog } from 'electron';
7 |
8 | import { makeSuccessResp, makeFailResp } from './ipcResponse';
9 | import type { Song, Songlist } from '../../type';
10 | import { buildSrcSongDepList } from './songDeps';
11 | import { globalStore } from '../../globalStore';
12 |
13 | export async function loadSonglistIPC(assetsPath: string) {
14 | log.info(`loadSonglistIPC(): assets: ${assetsPath}`);
15 | const songlistPath = path.join(assetsPath, 'songs', 'songlist');
16 | if (fs.existsSync(songlistPath)) {
17 | const songlistString = fs.readFileSync(songlistPath).toString();
18 |
19 | try {
20 | const songlist = JSON.parse(songlistString);
21 | if ('songs' in songlist && Array.isArray(songlist.songs)) {
22 | return makeSuccessResp(songlist.songs);
23 | }
24 | return makeFailResp('songlist格式错误');
25 | } catch (e) {
26 | return makeFailResp((e as Error).toString());
27 | }
28 | }
29 | return makeFailResp('不合法的Assets文件夹：未找到songlist');
30 | }
31 |
32 | export async function saveSonglistIPC(songlist: Songlist) {
33 | log.info(`saveSongsIPC()`);
34 | const assetsPath = globalStore.get('assets.path') as string;
35 | const songlistPath = path.join(assetsPath, 'songs', 'songlist');
36 | if (fs.existsSync(songlistPath)) {
37 | try {
38 | fs.writeFileSync(songlistPath, JSON.stringify(songlist, undefined, 2));
39 | return makeSuccessResp({});
40 | } catch (e) {
41 | return makeFailResp((e as Error).toString());
42 | }
43 | }
44 | return makeFailResp('不合法的Assets文件夹：未找到songlist');
45 | }
46 |
47 | export async function deleteSongsIPC(ids: string[]) {
48 | log.info(`deleteSongsIPC(): ${ids.join(',')}`);
49 | const assetsPath = globalStore.get('assets.path') as string;
50 | const deleteSongPromises = ids.map(
51 | (songId) =>
52 | new Promise((resolve, reject) => {
53 | const songDir = path.join(assetsPath, 'songs', songId);
54 | log.info(`deleting ${songDir}`);
55 | try {
56 | fs.rmSync(songDir, { recursive: true, force: true });
57 | resolve();
58 | } catch (e) {
59 | log.error(e);
60 | reject(e);
61 | }
62 | })
63 | );
64 | const deleteSongResults = await Promise.allSettled(deleteSongPromises);
65 | for (const result of deleteSongResults) {
66 | if (result.status === 'rejected') {
67 | return makeFailResp(result.reason);
68 | }
69 | }
70 | return makeSuccessResp({});
71 | }
72 |
73 | export async function importSong(
74 | src: string,
75 | assets: string
76 | ): Promise {
77 | log.info(`importSong(): trying import song from ${src} to ${assets}`);
78 | const srcSonglistPath = path.join(src, 'songlist');
79 | if (fs.existsSync(srcSonglistPath)) {
80 | const srcSonglistString = fs.readFileSync(srcSonglistPath).toString();
81 | const srcSonglist = JSON.parse(srcSonglistString);
82 | if (Array.isArray(srcSonglist.songs) && srcSonglist.songs.length > 0) {
83 | const srcSong = srcSonglist.songs[0] as Song;
84 | const destSongPath = path.join(assets, 'songs', srcSong.id);
85 |
86 | if (!fs.existsSync(destSongPath)) {
87 | fs.mkdirSync(destSongPath);
88 | }
89 |
90 | const srcFiles = await buildSrcSongDepList(srcSong);
91 |
92 | srcFiles.concat('songlist').forEach((file) => {
93 | const fullSrcPath = path.join(src, file);
94 | const fullDestPath = path.join(destSongPath, file);
95 | log.verbose(fullSrcPath, ' -> ', fullDestPath);
96 |
97 | fs.copyFileSync(fullSrcPath, fullDestPath);
98 | });
99 |
100 | return srcSong;
101 | }
102 | }
103 | return undefined;
104 | }
105 |
106 | export async function mergeSonglist(src: Song[], dest: Song[]) {
107 | log.info(`mergeSonglist()`);
108 | src.forEach((song) => {
109 | if (!dest.find((s) => s.id === song.id)) {
110 | dest.push(song);
111 | } else {
112 | const destIndex = dest.findIndex((s) => s.id === song.id);
113 | dest[destIndex] = song;
114 | }
115 | });
116 | return dest;
117 | }
118 |
119 | export async function verifyAssets(path: string) {}
120 |
121 | export async function makePackage(
122 | src: string,
123 | dest: string,
124 | mainWindow?: BrowserWindow
125 | ): Promise {
126 | log.info(`makePackage(): ${src} -> ${dest}`);
127 | mainWindow?.webContents.send('aam:startGeneratePackage');
128 | const sysTemp = app.getPath('temp');
129 | const tmpDir = fs.mkdtempSync(path.join(sysTemp, 'aam-assets-'));
130 | const tmpPackagePath = path.join(tmpDir, path.basename(dest));
131 |
132 | const assetContains = await fsAsync.readdir(src);
133 | const output = fs.createWriteStream(tmpPackagePath);
134 | const archive = archiver('zip');
135 | archive.pipe(output);
136 | for (const rootAsset of assetContains) {
137 | const fullRootAssetPath = path.join(src, rootAsset);
138 | if (fs.lstatSync(fullRootAssetPath).isFile()) {
139 | archive.file(fullRootAssetPath, { name: rootAsset });
140 | } else {
141 | archive.directory(fullRootAssetPath, rootAsset);
142 | }
143 | }
144 |
145 | const parseSize = (size: number) => {
146 | if (size < 1024) {
147 | return `${size} B`;
148 | }
149 | if (size < 1024 * 1024) {
150 | return `${(size / 1024).toFixed(2)} KB`;
151 | }
152 | if (size < 1024 * 1024 * 1024) {
153 | return `${(size / 1024 / 1024).toFixed(2)} MB`;
154 | }
155 | return `${(size / 1024 / 1024 / 1024).toFixed(2)} GB`;
156 | };
157 |
158 | let lastReport = Date.now();
159 | archive.on('entry', () => {
160 | const now = Date.now();
161 | if (now - lastReport > 1000) {
162 | const size = archive.pointer();
163 | mainWindow?.webContents.send('aam:log', parseSize(size));
164 | lastReport = Date.now();
165 | }
166 | });
167 |
168 | // const progressHandler = (e: ProgressData) => {
169 | // log.debug(`${e.entries.processed} entries / ${e.fs.processedBytes} bytes`);
170 | // mainWindow?.webContents.send(
171 | // 'aam:log',
172 | // `${(e.fs.processedBytes / 1024 / 1024).toLocaleString(undefined, {
173 | // maximumFractionDigits: 2,
174 | // })} MB`
175 | // );
176 | // setTimeout(() => {
177 | // archive.once('progress', progressHandler);
178 | // }, 1000);
179 | // };
180 | // archive.once('progress', progressHandler);
181 |
182 | await archive.finalize().catch((e: Error) => {
183 | log.error(e);
184 | dialog.showErrorBox('打包错误', e.toString());
185 | });
186 |
187 | await new Promise((resolve) => {
188 | // 文件流关闭时触发复制
189 | output.once('close', () => {
190 | try {
191 | mainWindow?.webContents.send('aam:log', '即将完成...');
192 | log.info(`打包完成，复制文件 ${tmpPackagePath} -> ${dest}`);
193 | fs.copyFileSync(tmpPackagePath, dest);
194 | mainWindow?.webContents.send('aam:stopGeneratePackage');
195 | dialog.showMessageBox({
196 | message: '导出成功',
197 | detail: `已导出：${dest}`,
198 | });
199 | resolve();
200 | } catch (e) {
201 | log.error(e);
202 | dialog.showErrorBox('打包错误', (e as Error).toString());
203 | } finally {
204 | log.info(`清理 ${tmpDir}`);
205 | fs.rmSync(tmpDir, { recursive: true });
206 | }
207 | });
208 | });
209 | }
210 |
--------------------------------------------------------------------------------
/src/main/main.ts:
--------------------------------------------------------------------------------
1 | /* eslint global-require: off, no-console: off, promise/always-return: off */
2 |
3 | /**
4 | * This module executes inside of electron's main process. You can start
5 | * electron renderer process from here and communicate with the other processes
6 | * through IPC.
7 | *
8 | * When running `npm run build` or `npm run build:main`, this file is compiled to
9 | * `./src/main.js` using webpack. This gives us some performance wins.
10 | */
11 | import path from 'path';
12 | import fs from 'fs';
13 | import { app, BrowserWindow, shell, ipcMain, dialog } from 'electron';
14 | // import { autoUpdater } from 'electron-updater';
15 | import log, { LevelOption } from 'electron-log';
16 | import installExtension, { REDUX_DEVTOOLS } from 'electron-devtools-installer';
17 | import { AppInfo, Song, Songlist } from 'type';
18 |
19 | import MenuBuilder from './menu';
20 | import { resolveHtmlPath } from './util';
21 | import { makeFailResp, makeSuccessResp } from './utils/ipcResponse';
22 | import {
23 | deleteSongsIPC,
24 | loadSonglistIPC,
25 | saveSonglistIPC,
26 | } from './utils/assets';
27 | import { globalStore } from '../globalStore';
28 |
29 | // class AppUpdater {
30 | // constructor() {
31 | // log.transports.file.level = 'info';
32 | // autoUpdater.logger = log;
33 | // autoUpdater.checkForUpdatesAndNotify();
34 | // }
35 | // }
36 |
37 | let mainWindow: BrowserWindow | null = null;
38 |
39 | if (process.env.NODE_ENV === 'production') {
40 | const sourceMapSupport = require('source-map-support');
41 | sourceMapSupport.install();
42 | }
43 |
44 | const isDebug =
45 | process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true';
46 |
47 | if (isDebug) {
48 | require('electron-debug')();
49 | }
50 |
51 | const installExtensions = async () => {
52 | const installer = require('electron-devtools-installer');
53 | const forceDownload = !!process.env.UPGRADE_EXTENSIONS;
54 | const extensions = ['REACT_DEVELOPER_TOOLS'];
55 |
56 | return installer
57 | .default(
58 | extensions.map((name) => installer[name]),
59 | forceDownload
60 | )
61 | .catch(console.log);
62 | };
63 |
64 | const createWindow = async () => {
65 | if (isDebug) {
66 | await installExtensions();
67 | }
68 |
69 | const RESOURCES_PATH = app.isPackaged
70 | ? path.join(process.resourcesPath, 'assets')
71 | : path.join(__dirname, '../../assets');
72 |
73 | const getAssetPath = (...paths: string[]): string => {
74 | return path.join(RESOURCES_PATH, ...paths);
75 | };
76 |
77 | mainWindow = new BrowserWindow({
78 | show: false,
79 | width: 1015,
80 | height: 620,
81 | icon: getAssetPath('icon.png'),
82 | webPreferences: {
83 | preload: app.isPackaged
84 | ? path.join(__dirname, 'preload.js')
85 | : path.join(__dirname, '../../.erb/dll/preload.js'),
86 | },
87 | });
88 |
89 | mainWindow.loadURL(resolveHtmlPath('index.html'));
90 |
91 | mainWindow.on('ready-to-show', () => {
92 | if (!mainWindow) {
93 | throw new Error('"mainWindow" is not defined');
94 | }
95 | if (process.env.START_MINIMIZED) {
96 | mainWindow.minimize();
97 | } else {
98 | mainWindow.show();
99 | }
100 | });
101 |
102 | mainWindow.on('close', (e) => {
103 | if (mainWindow && !isDebug) {
104 | const response = dialog.showMessageBoxSync(mainWindow, {
105 | message: '要退出吗？',
106 | type: 'question',
107 | buttons: ['好', '取消'],
108 | defaultId: 0,
109 | title: '退出',
110 | detail: '所有更改已自动保存。',
111 | cancelId: 1,
112 | });
113 | if (response === 1) {
114 | e.preventDefault();
115 | } else {
116 | globalStore.reset('assets');
117 | }
118 | }
119 | });
120 |
121 | mainWindow.on('closed', () => {
122 | mainWindow = null;
123 | });
124 |
125 | const menuBuilder = new MenuBuilder(mainWindow);
126 | const menu = menuBuilder.buildMenu();
127 |
128 | globalStore.onDidChange('assets.path', (newValue) => {
129 | log.debug(!!newValue, menu.getMenuItemById('file.import')?.enabled);
130 | menu.getMenuItemById('file.import.song')!.enabled = !!newValue;
131 | menu.getMenuItemById('file.import.songLink')!.enabled = !!newValue;
132 | menu.getMenuItemById('file.import.bg')!.enabled = !!newValue;
133 |
134 | menu.getMenuItemById('file.closeFolder')!.enabled = !!newValue;
135 |
136 | menu.getMenuItemById('build.build')!.enabled = !!newValue;
137 | menu.getMenuItemById('build.verify')!.enabled = !!newValue;
138 | });
139 |
140 | // Open urls in the user's browser
141 | mainWindow.webContents.setWindowOpenHandler((edata) => {
142 | shell.openExternal(edata.url);
143 | return { action: 'deny' };
144 | });
145 |
146 | // // Remove this if your app does not use auto updates
147 | // // eslint-disable-next-line
148 | // new AppUpdater();
149 | };
150 |
151 | /**
152 | * Add event listeners...
153 | */
154 |
155 | app.on('window-all-closed', () => {
156 | app.quit();
157 | });
158 |
159 | app
160 | .whenReady()
161 | .then(() => {
162 | installExtension(REDUX_DEVTOOLS)
163 | .then((name) => console.log(`Added Extension: ${name}`))
164 | .catch((err) => console.log('An error occurred: ', err));
165 |
166 | createWindow();
167 |
168 | log.transports.file.level = globalStore.get('settings.logLevel');
169 |
170 | ipcMain.on('electron-store-get', async (event, val) => {
171 | event.returnValue = globalStore.get(val);
172 | });
173 | ipcMain.on('electron-store-set', async (event, key, val) => {
174 | globalStore.set(key, val);
175 | });
176 |
177 | globalStore.onDidChange('assets', (newValue) => {
178 | mainWindow?.webContents.send(
179 | 'aam:pushSongs',
180 | (newValue as { assets: unknown }).assets
181 | );
182 | });
183 |
184 | globalStore.onDidChange('settings.logLevel', (newValue: LevelOption) => {
185 | if (newValue) {
186 | log.transports.file.level = newValue;
187 | }
188 | log.info(log.transports.file.resolvePath);
189 | });
190 |
191 | ipcMain.handle('dialog:openDirectory', async () => {
192 | if (mainWindow) {
193 | const { canceled, filePaths } = await dialog.showOpenDialog(
194 | mainWindow,
195 | {
196 | properties: ['openDirectory', 'treatPackageAsDirectory'],
197 | }
198 | );
199 | if (canceled) {
200 | return '';
201 | }
202 | return filePaths[0];
203 | }
204 | return '';
205 | });
206 |
207 | ipcMain.handle('aam:loadSongs', async (_, assetsPath: string) => {
208 | const songlist = await loadSonglistIPC(assetsPath);
209 | if (songlist.code !== 0) {
210 | dialog.showErrorBox('错误', songlist.message);
211 | }
212 | return songlist;
213 | });
214 | ipcMain.handle('aam:saveSonglist', async (_, songlist: Songlist) => {
215 | const resp = await saveSonglistIPC(songlist);
216 | if (resp.code !== 0) {
217 | dialog.showErrorBox('错误', resp.message);
218 | }
219 | return resp;
220 | });
221 | ipcMain.handle('aam:deleteSongs', async (_, ids: string[]) => {
222 | const resp = await deleteSongsIPC(ids);
223 | if (resp.code !== 0) {
224 | dialog.showErrorBox('错误', resp.message);
225 | }
226 | return resp;
227 | });
228 |
229 | ipcMain.handle('showLogFile', async () => {
230 | shell.openPath(path.dirname(log.transports.file.getFile().path));
231 | });
232 |
233 | ipcMain.handle('reset', async () => {
234 | globalStore.reset('settings');
235 | app.exit();
236 | });
237 |
238 | ipcMain.handle('getAppInfo', async () => {
239 | return {
240 | version: app.getVersion(),
241 | isDebug,
242 | } as AppInfo;
243 | });
244 | })
245 | .catch(console.log);
246 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "description": "一个Arcaea资产管理工具",
3 | "keywords": [
4 | "electron",
5 | "react",
6 | "typescript",
7 | "arcaea"
8 | ],
9 | "homepage": "https://github.com/feightwywx/aam#readme",
10 | "bugs": {
11 | "url": "https://github.com/feightwywx/aam/issues"
12 | },
13 | "repository": {
14 | "type": "git",
15 | "url": "git+https://github.com/feightwywx/aam.git"
16 | },
17 | "license": "MIT",
18 | "author": {
19 | "name": ".direwolf",
20 | "email": "canis@direcore.xyz",
21 | "url": "https://drwf.ink"
22 | },
23 | "main": "./src/main/main.ts",
24 | "scripts": {
25 | "build": "concurrently \"npm run build:main\" \"npm run build:renderer\"",
26 | "build:main": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.main.prod.ts",
27 | "build:renderer": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.renderer.prod.ts",
28 | "postinstall": "ts-node .erb/scripts/check-native-dep.js && electron-builder install-app-deps && cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.renderer.dev.dll.ts",
29 | "lint": "cross-env NODE_ENV=development eslint . --ext .js,.jsx,.ts,.tsx",
30 | "package": "ts-node ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never",
31 | "prepare": "husky install",
32 | "rebuild": "electron-rebuild --parallel --types prod,dev,optional --module-dir release/app",
33 | "start": "ts-node ./.erb/scripts/check-port-in-use.js && npm run start:renderer",
34 | "start:main": "cross-env NODE_ENV=development electronmon -r ts-node/register/transpile-only .",
35 | "start:preload": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.preload.dev.ts",
36 | "start:renderer": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./.erb/configs/webpack.config.renderer.dev.ts",
37 | "test": "jest"
38 | },
39 | "lint-staged": {
40 | "*.{js,jsx,ts,tsx}": [
41 | "cross-env NODE_ENV=development eslint --cache"
42 | ],
43 | "*.json,.{eslintrc,prettierrc}": [
44 | "prettier --ignore-path .eslintignore --parser json --write"
45 | ],
46 | "*.{css,scss}": [
47 | "prettier --ignore-path .eslintignore --single-quote --write"
48 | ],
49 | "*.{html,md,yml}": [
50 | "prettier --ignore-path .eslintignore --single-quote --write"
51 | ]
52 | },
53 | "browserslist": [],
54 | "prettier": {
55 | "singleQuote": true,
56 | "overrides": [
57 | {
58 | "files": [
59 | ".prettierrc",
60 | ".eslintrc"
61 | ],
62 | "options": {
63 | "parser": "json"
64 | }
65 | }
66 | ]
67 | },
68 | "jest": {
69 | "moduleDirectories": [
70 | "node_modules",
71 | "release/app/node_modules",
72 | "src"
73 | ],
74 | "moduleFileExtensions": [
75 | "js",
76 | "jsx",
77 | "ts",
78 | "tsx",
79 | "json"
80 | ],
81 | "moduleNameMapper": {
82 | "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "/.erb/mocks/fileMock.js",
83 | "\\.(css|less|sass|scss)$": "identity-obj-proxy"
84 | },
85 | "setupFiles": [
86 | "./.erb/scripts/check-build-exists.ts"
87 | ],
88 | "testEnvironment": "jsdom",
89 | "testEnvironmentOptions": {
90 | "url": "http://localhost/"
91 | },
92 | "testPathIgnorePatterns": [
93 | "release/app/dist"
94 | ],
95 | "transform": {
96 | "\\.(ts|tsx|js|jsx)$": "ts-jest"
97 | }
98 | },
99 | "dependencies": {
100 | "@ant-design/icons": "^5.0.1",
101 | "@monaco-editor/react": "^4.4.6",
102 | "@reduxjs/toolkit": "^1.9.1",
103 | "antd": "^5.2.3",
104 | "archiver": "^5.3.1",
105 | "electron-debug": "^3.2.0",
106 | "electron-log": "^4.4.8",
107 | "electron-redux": "^1.5.4",
108 | "electron-store": "^8.1.0",
109 | "electron-updater": "^5.2.3",
110 | "monaco-editor": "^0.36.1",
111 | "path-browserify": "^1.0.1",
112 | "react": "^18.2.0",
113 | "react-dom": "^18.2.0",
114 | "react-redux": "^8.0.5",
115 | "react-router-dom": "^6.4.5",
116 | "redux": "^4.2.0",
117 | "usehooks-ts": "^2.9.1"
118 | },
119 | "devDependencies": {
120 | "@pmmmwh/react-refresh-webpack-plugin": "^0.5.7",
121 | "@redux-devtools/core": "^3.13.1",
122 | "@svgr/webpack": "^6.3.1",
123 | "@teamsupercell/typings-for-css-modules-loader": "^2.5.1",
124 | "@testing-library/jest-dom": "^5.16.5",
125 | "@testing-library/react": "^13.3.0",
126 | "@types/archiver": "^5.3.1",
127 | "@types/jest": "^28.1.7",
128 | "@types/node": "18.7.6",
129 | "@types/react": "^18.0.17",
130 | "@types/react-dom": "^18.0.6",
131 | "@types/react-test-renderer": "^18.0.0",
132 | "@types/terser-webpack-plugin": "^5.0.4",
133 | "@types/webpack-bundle-analyzer": "^4.4.2",
134 | "@typescript-eslint/eslint-plugin": "^5.33.1",
135 | "@typescript-eslint/parser": "^5.33.1",
136 | "browserslist-config-erb": "^0.0.3",
137 | "chalk": "^4.1.2",
138 | "concurrently": "^7.3.0",
139 | "copy-webpack-plugin": "^11.0.0",
140 | "core-js": "^3.24.1",
141 | "cross-env": "^7.0.3",
142 | "css-loader": "^6.7.1",
143 | "css-minimizer-webpack-plugin": "^4.0.0",
144 | "detect-port": "^1.3.0",
145 | "electron": "^20.0.2",
146 | "electron-builder": "^23.3.3",
147 | "electron-devtools-installer": "^3.2.0",
148 | "electron-notarize": "^1.2.1",
149 | "electron-rebuild": "^3.2.9",
150 | "electronmon": "^2.0.2",
151 | "eslint": "^8.22.0",
152 | "eslint-config-airbnb-base": "^15.0.0",
153 | "eslint-config-erb": "^4.0.3",
154 | "eslint-import-resolver-typescript": "^3.4.1",
155 | "eslint-import-resolver-webpack": "^0.13.2",
156 | "eslint-plugin-compat": "^4.0.2",
157 | "eslint-plugin-import": "^2.26.0",
158 | "eslint-plugin-jest": "^26.8.3",
159 | "eslint-plugin-jsx-a11y": "^6.6.1",
160 | "eslint-plugin-promise": "^6.0.0",
161 | "eslint-plugin-react": "^7.30.1",
162 | "eslint-plugin-react-hooks": "^4.6.0",
163 | "file-loader": "^6.2.0",
164 | "html-webpack-plugin": "^5.5.0",
165 | "husky": "^8.0.1",
166 | "identity-obj-proxy": "^3.0.0",
167 | "jest": "^28.1.3",
168 | "jest-environment-jsdom": "^28.1.3",
169 | "lint-staged": "^13.0.3",
170 | "mini-css-extract-plugin": "^2.6.1",
171 | "monaco-editor-webpack-plugin": "^7.0.1",
172 | "prettier": "^2.7.1",
173 | "react-refresh": "^0.14.0",
174 | "react-test-renderer": "^18.2.0",
175 | "rimraf": "^3.0.2",
176 | "sass": "^1.54.4",
177 | "sass-loader": "^13.0.2",
178 | "style-loader": "^3.3.1",
179 | "terser-webpack-plugin": "^5.3.5",
180 | "ts-jest": "^28.0.8",
181 | "ts-loader": "^9.3.1",
182 | "ts-node": "^10.9.1",
183 | "typescript": "^4.7.4",
184 | "url-loader": "^4.1.1",
185 | "webpack": "^5.74.0",
186 | "webpack-bundle-analyzer": "^4.5.0",
187 | "webpack-cli": "^4.10.0",
188 | "webpack-dev-server": "^4.10.0",
189 | "webpack-merge": "^5.8.0"
190 | },
191 | "build": {
192 | "productName": "Arcaea Assets Manager",
193 | "appId": "icu.arcaea.am",
194 | "asar": true,
195 | "asarUnpack": "**\\*.{node,dll}",
196 | "files": [
197 | "dist",
198 | "node_modules",
199 | "package.json"
200 | ],
201 | "afterSign": ".erb/scripts/notarize.js",
202 | "mac": {
203 | "target": {
204 | "target": "default",
205 | "arch": [
206 | "arm64",
207 | "x64"
208 | ]
209 | },
210 | "type": "distribution",
211 | "hardenedRuntime": true,
212 | "entitlements": "assets/entitlements.mac.plist",
213 | "entitlementsInherit": "assets/entitlements.mac.plist",
214 | "gatekeeperAssess": false
215 | },
216 | "dmg": {
217 | "contents": [
218 | {
219 | "x": 130,
220 | "y": 220
221 | },
222 | {
223 | "x": 410,
224 | "y": 220,
225 | "type": "link",
226 | "path": "/Applications"
227 | }
228 | ]
229 | },
230 | "win": {
231 | "target": [
232 | "zip"
233 | ]
234 | },
235 | "linux": {
236 | "target": [
237 | "AppImage",
238 | "deb",
239 | "tar.xz"
240 | ],
241 | "category": "Development"
242 | },
243 | "directories": {
244 | "app": "release/app",
245 | "buildResources": "assets",
246 | "output": "release/build"
247 | },
248 | "extraResources": [
249 | "./assets/**"
250 | ],
251 | "publish": {
252 | "provider": "github",
253 | "owner": "feightwywx",
254 | "repo": "aam"
255 | }
256 | },
257 | "devEngines": {
258 | "node": ">=14.x",
259 | "npm": ">=7.x"
260 | },
261 | "electronmon": {
262 | "patterns": [
263 | "!**/**",
264 | "src/main/**"
265 | ],
266 | "logLevel": "quiet"
267 | }
268 | }
269 |
--------------------------------------------------------------------------------
/src/main/menu.ts:
--------------------------------------------------------------------------------
1 | import {
2 | app,
3 | Menu,
4 | shell,
5 | BrowserWindow,
6 | MenuItemConstructorOptions,
7 | dialog,
8 | } from 'electron';
9 | import log from 'electron-log';
10 |
11 | import { globalStore } from '../globalStore';
12 | import { loadSonglistIPC } from './utils/assets';
13 | import {
14 | generatePackageMenuHandlerFactory,
15 | importBgMenuHandlerFactory,
16 | importSongMenuHandlerFactory,
17 | verifyMenuHandlerFactory,
18 | } from './menuHandler';
19 |
20 | interface DarwinMenuItemConstructorOptions extends MenuItemConstructorOptions {
21 | selector?: string;
22 | submenu?: DarwinMenuItemConstructorOptions[] | Menu;
23 | }
24 |
25 | export default class MenuBuilder {
26 | mainWindow: BrowserWindow;
27 |
28 | constructor(mainWindow: BrowserWindow) {
29 | this.mainWindow = mainWindow;
30 | }
31 |
32 | buildMenu(): Menu {
33 | if (
34 | process.env.NODE_ENV === 'development' ||
35 | process.env.DEBUG_PROD === 'true'
36 | ) {
37 | this.setupDevelopmentEnvironment();
38 | }
39 |
40 | const template =
41 | process.platform === 'darwin'
42 | ? this.buildDarwinTemplate()
43 | : this.buildDefaultTemplate();
44 |
45 | const menu = Menu.buildFromTemplate(template);
46 | Menu.setApplicationMenu(menu);
47 |
48 | return menu;
49 | }
50 |
51 | setupDevelopmentEnvironment(): void {
52 | this.mainWindow.webContents.on('context-menu', (_, props) => {
53 | const { x, y } = props;
54 |
55 | Menu.buildFromTemplate([
56 | {
57 | label: '审查元素',
58 | click: () => {
59 | this.mainWindow.webContents.inspectElement(x, y);
60 | },
61 | },
62 | ]).popup({ window: this.mainWindow });
63 | });
64 | }
65 |
66 | buildDarwinTemplate(): MenuItemConstructorOptions[] {
67 | const subMenuAbout: DarwinMenuItemConstructorOptions = {
68 | label: 'Arcaea 资产管理器',
69 | submenu: [
70 | {
71 | label: '关于 AAM',
72 | selector: 'orderFrontStandardAboutPanel:',
73 | },
74 | { type: 'separator' },
75 | {
76 | label: '打开...',
77 | accelerator: 'Command+O',
78 | click: async () => {
79 | const { canceled, filePaths } = await dialog.showOpenDialog(
80 | this.mainWindow,
81 | {
82 | properties: ['openDirectory', 'treatPackageAsDirectory'],
83 | }
84 | );
85 | if (!canceled) {
86 | const songlist = await loadSonglistIPC(filePaths[0]);
87 | if (songlist.code === 0) {
88 | this.mainWindow.webContents.send('aam:pushSongs', {
89 | path: filePaths[0],
90 | songs: songlist.data,
91 | });
92 | } else {
93 | dialog.showErrorBox('错误', songlist.message);
94 | }
95 | }
96 | },
97 | },
98 | {
99 | id: 'file.import',
100 | label: '导入',
101 | submenu: [
102 | {
103 | id: 'file.import.song',
104 | label: '歌曲',
105 | accelerator: 'Command+I',
106 | click: importSongMenuHandlerFactory(this.mainWindow),
107 | enabled: false,
108 | },
109 | {
110 | id: 'file.import.songLink',
111 | label: '歌曲（链接模式）',
112 | accelerator: 'Shift+Command+I',
113 | click: importSongMenuHandlerFactory(this.mainWindow, true),
114 | enabled: false,
115 | },
116 | { type: 'separator' },
117 | {
118 | id: 'file.import.bg',
119 | label: '背景',
120 | click: importBgMenuHandlerFactory(this.mainWindow),
121 | enabled: false,
122 | },
123 | ],
124 | },
125 | {
126 | id: 'file.closeFolder',
127 | label: '关闭文件夹',
128 | accelerator: 'Shift+Command+W',
129 | click: () => {
130 | this.mainWindow.webContents.send('aam:closeFolder');
131 | },
132 | enabled: false,
133 | },
134 | { type: 'separator' },
135 | { label: '服务', role: 'services', submenu: [] },
136 | { type: 'separator' },
137 | {
138 | label: '隐藏 AAM',
139 | accelerator: 'Command+H',
140 | selector: 'hide:',
141 | },
142 | {
143 | label: '隐藏其他',
144 | accelerator: 'Command+Shift+H',
145 | selector: 'hideOtherApplications:',
146 | },
147 | { label: '全部显示', selector: 'unhideAllApplications:' },
148 | { type: 'separator' },
149 | {
150 | label: '退出 AAM',
151 | accelerator: 'Command+Q',
152 | click: () => {
153 | app.quit();
154 | },
155 | },
156 | ],
157 | };
158 | const subMenuEdit: DarwinMenuItemConstructorOptions = {
159 | label: '编辑',
160 | submenu: [
161 | { label: '撤销', accelerator: 'Command+Z', selector: 'undo:' },
162 | { label: '重做', accelerator: 'Shift+Command+Z', selector: 'redo:' },
163 | { type: 'separator' },
164 | { label: '剪切', accelerator: 'Command+X', selector: 'cut:' },
165 | { label: '复制', accelerator: 'Command+C', selector: 'copy:' },
166 | { label: '粘贴', accelerator: 'Command+V', selector: 'paste:' },
167 | {
168 | label: '全选',
169 | accelerator: 'Command+A',
170 | selector: 'selectAll:',
171 | },
172 | ],
173 | };
174 | const subMenuBuild: DarwinMenuItemConstructorOptions = {
175 | id: 'build',
176 | label: '生成',
177 | submenu: [
178 | {
179 | id: 'build.build',
180 | label: '生成...',
181 | accelerator: 'F5',
182 | click: generatePackageMenuHandlerFactory(this.mainWindow),
183 | enabled: false,
184 | },
185 | { type: 'separator' },
186 | {
187 | id: 'build.verify',
188 | label: '验证依赖',
189 | accelerator: 'F6',
190 | click: verifyMenuHandlerFactory(this.mainWindow),
191 | enabled: false,
192 | },
193 | ],
194 | };
195 | const subMenuViewDev: MenuItemConstructorOptions = {
196 | label: '查看',
197 | submenu: [
198 | {
199 | label: '重新载入',
200 | accelerator: 'Command+R',
201 | click: () => {
202 | this.mainWindow.webContents.reload();
203 | },
204 | },
205 | {
206 | label: '切换全屏幕',
207 | accelerator: 'Ctrl+Command+F',
208 | click: () => {
209 | this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
210 | },
211 | },
212 | {
213 | label: '切换开发者工具',
214 | accelerator: 'Alt+Command+I',
215 | click: () => {
216 | this.mainWindow.webContents.toggleDevTools();
217 | },
218 | },
219 | ],
220 | };
221 | const subMenuViewProd: MenuItemConstructorOptions = {
222 | label: '查看',
223 | submenu: [
224 | {
225 | label: '切换全屏幕',
226 | accelerator: 'Ctrl+Command+F',
227 | click: () => {
228 | this.mainWindow.setFullScreen(!this.mainWindow.isFullScreen());
229 | },
230 | },
231 | ],
232 | };
233 | const subMenuWindow: DarwinMenuItemConstructorOptions = {
234 | label: '窗口',
235 | role: 'window',
236 | submenu: [
237 | {
238 | label: '最小化',
239 | accelerator: 'Command+M',
240 | selector: 'performMiniaturize:',
241 | },
242 | { label: '关闭', accelerator: 'Command+W', selector: 'performClose:' },
243 | { type: 'separator' },
244 | { label: '全部置于顶层', selector: 'arrangeInFront:' },
245 | ],
246 | };
247 | const subMenuHelp: MenuItemConstructorOptions = {
248 | label: '帮助',
249 | role: 'help',
250 | submenu: [
251 | {
252 | label: '了解更多',
253 | click() {
254 | shell.openExternal('https://github.com/feightwywx/aam');
255 | },
256 | },
257 | ],
258 | };
259 |
260 | const subMenuView =
261 | process.env.NODE_ENV === 'development' ||
262 | process.env.DEBUG_PROD === 'true'
263 | ? subMenuViewDev
264 | : subMenuViewProd;
265 |
266 | return [
267 | subMenuAbout,
268 | subMenuEdit,
269 | subMenuBuild,
270 | subMenuView,
271 | subMenuWindow,
272 | subMenuHelp,
273 | ];
274 | }
275 |
276 | buildDefaultTemplate() {
277 | const templateDefault = [
278 | {
279 | label: '文件(&F)',
280 | submenu: [
281 | {
282 | label: '打开...(&O)',
283 | accelerator: 'Ctrl+O',
284 | click: async () => {
285 | const { canceled, filePaths } = await dialog.showOpenDialog(
286 | this.mainWindow,
287 | {
288 | properties: ['openDirectory', 'treatPackageAsDirectory'],
289 | }
290 | );
291 | if (!canceled) {
292 | const songlist = await loadSonglistIPC(filePaths[0]);
293 | if (songlist.code === 0) {
294 | this.mainWindow.webContents.send('aam:pushSongs', {
295 | path: filePaths[0],
296 | songs: songlist.data,
297 | });
298 | } else {
299 | dialog.showErrorBox('错误', songlist.message);
300 | }
301 | }
302 | },
303 | },
304 | {
305 | id: 'file.import',
306 | label: '导入',
307 | submenu: [
308 | {
309 | id: 'file.import.song',
310 | label: '歌曲(&S)',
311 | accelerator: 'Ctrl+I',
312 | click: importSongMenuHandlerFactory(this.mainWindow),
313 | enabled: false,
314 | },
315 | {
316 | id: 'file.import.songLink',
317 | label: '歌曲（链接模式）(&L)',
318 | accelerator: 'Shift+Ctrl+I',
319 | click: importSongMenuHandlerFactory(this.mainWindow, true),
320 | enabled: false,
321 | },
322 | { type: 'separator' },
323 | {
324 | id: 'file.import.bg',
325 | label: '背景(&B)',
326 | click: importBgMenuHandlerFactory(this.mainWindow),
327 | enabled: false,
328 | },
329 | ],
330 | },
331 | {
332 | id: 'file.closeFolder',
333 | label: '关闭文件夹(&F)',
334 | accelerator: 'Shift+Ctrl+W',
335 | click: () => {
336 | this.mainWindow.webContents.send('aam:closeFolder');
337 | },
338 | enabled: false,
339 | },
340 | {
341 | label: '关闭(&C)',
342 | accelerator: 'Ctrl+W',
343 | click: () => {
344 | this.mainWindow.close();
345 | },
346 | },
347 | ],
348 | },
349 | {
350 | label: '生成(&B)',
351 | submenu: [
352 | {
353 | id: 'build.build',
354 | label: '生成...(&G)',
355 | accelerator: 'F5',
356 | click: generatePackageMenuHandlerFactory(this.mainWindow),
357 | enabled: false,
358 | },
359 | { type: 'separator' },
360 | {
361 | id: 'build.verify',
362 | label: '验证依赖(&V)',
363 | accelerator: 'F6',
364 | click: verifyMenuHandlerFactory(this.mainWindow),
365 | enabled: false,
366 | },
367 | ],
368 | },
369 | {
370 | label: '查看(&V)',
371 | submenu:
372 | process.env.NODE_ENV === 'development' ||
373 | process.env.DEBUG_PROD === 'true'
374 | ? [
375 | {
376 | label: '重新加载(&R)',
377 | accelerator: 'Ctrl+R',
378 | click: () => {
379 | this.mainWindow.webContents.reload();
380 | },
381 | },
382 | {
383 | label: '切换全屏(&F)',
384 | accelerator: 'F11',
385 | click: () => {
386 | this.mainWindow.setFullScreen(
387 | !this.mainWindow.isFullScreen()
388 | );
389 | },
390 | },
391 | {
392 | label: '切换开发者工具(&D)',
393 | accelerator: 'Alt+Ctrl+I',
394 | click: () => {
395 | this.mainWindow.webContents.toggleDevTools();
396 | },
397 | },
398 | ]
399 | : [
400 | {
401 | label: '切换全屏(&F)',
402 | accelerator: 'F11',
403 | click: () => {
404 | this.mainWindow.setFullScreen(
405 | !this.mainWindow.isFullScreen()
406 | );
407 | },
408 | },
409 | ],
410 | },
411 | {
412 | label: '帮助',
413 | submenu: [
414 | {
415 | label: '了解更多',
416 | click() {
417 | shell.openExternal('https://github.com/feightwywx/aam');
418 | },
419 | },
420 | ],
421 | },
422 | ];
423 |
424 | return templateDefault;
425 | }
426 | }
427 |
--------------------------------------------------------------------------------
/.erb/img/erb-banner.svg:
--------------------------------------------------------------------------------
1 |
33 |
--------------------------------------------------------------------------------
/src/renderer/pages/Songs.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | Button,
3 | Input,
4 | Menu,
5 | message,
6 | Modal,
7 | Popover,
8 | Space,
9 | Spin,
10 | Table,
11 | TableProps,
12 | Tag,
13 | theme,
14 | Tooltip,
15 | } from 'antd';
16 | import type { TableColumnsType } from 'antd';
17 |
18 | import './Hello.css';
19 | import { useNavigate } from 'react-router-dom';
20 | import type { SettingsType, Song, SongDifficulty } from 'type';
21 | import React, { useEffect, useRef, useState } from 'react';
22 | import type {
23 | FilterValue,
24 | SorterResult,
25 | TableRowSelection,
26 | } from 'antd/es/table/interface';
27 |
28 | import {
29 | BorderInnerOutlined,
30 | CheckCircleOutlined,
31 | CloseCircleOutlined,
32 | DashOutlined,
33 | DeleteOutlined,
34 | EditOutlined,
35 | ImportOutlined,
36 | ReloadOutlined,
37 | SearchOutlined,
38 | } from '@ant-design/icons';
39 |
40 | import { useAppDispatch, useAppSelector } from '../store';
41 | import { setSongs } from 'stateSlices/assets';
42 | import MonacoEditor from 'renderer/components/MonacoEditor';
43 |
44 | interface SongTableData extends Song {
45 | key: string;
46 | idWithExtFlag: {
47 | id: string;
48 | ext?: string;
49 | };
50 | title: string;
51 | bpm_combine: string;
52 | }
53 |
54 | function convertRatingClass(rating: number) {
55 | if (rating === 0) {
56 | return 'Past';
57 | }
58 | if (rating === 1) {
59 | return 'Present';
60 | }
61 | if (rating === 2) {
62 | return 'Future';
63 | }
64 | if (rating === 3) {
65 | return 'Beyond';
66 | }
67 | return 'Unknown';
68 | }
69 |
70 | function convertRatingClassColor(rating: number) {
71 | if (rating === 0) {
72 | return 'cyan';
73 | }
74 | if (rating === 1) {
75 | return 'green';
76 | }
77 | if (rating === 2) {
78 | return 'purple';
79 | }
80 | if (rating === 3) {
81 | return 'volcano';
82 | }
83 | return 'gray';
84 | }
85 |
86 | const Songs: React.FC = () => {
87 | const assets = useAppSelector((state) => state.assets);
88 | const dispatch = useAppDispatch();
89 | const navigate = useNavigate();
90 | const settings = window.electron.ipcRenderer.store.get(
91 | 'settings'
92 | ) as SettingsType;
93 |
94 | const [messageApi, contextHolder] = message.useMessage();
95 |
96 | const [filteredInfo, setFilteredInfo] = useState<
97 | Record
98 | >({});
99 |
100 | const handleTableChange: TableProps['onChange'] = (
101 | pagination,
102 | filters,
103 | sorter
104 | ) => {
105 | console.log('Various parameters', pagination, filters, sorter);
106 | setFilteredInfo(filters);
107 | };
108 |
109 | const column: TableColumnsType = [
110 | {
111 | title: 'ID',
112 | dataIndex: 'idWithExtFlag',
113 | key: 'id',
114 | width: 150,
115 | fixed: 'left',
116 | ellipsis: true,
117 | sorter: (a, b) => a.id.localeCompare(b.id),
118 | sortDirections: ['ascend', 'descend'],
119 | render: ({ id, ext }) => {
120 | return (
121 | <>
122 | {id}
123 | {ext && (
124 |
130 | 外
131 |
132 | )}
133 |
134 | );
135 | },
136 | },
137 | {
138 | title: '曲名',
139 | dataIndex: 'title_localized',
140 | key: 'title_localized',
141 | width: 250,
142 | ellipsis: true,
143 | sorter: (a, b) =>
144 | a.title_localized.en.localeCompare(b.title_localized.en, 'ja'),
145 | sortDirections: ['ascend', 'descend'],
146 | render: (title: { en: string; ja?: string }) => (
147 | <>
148 | EN
149 | {title.en}
150 | {title.ja && (
151 | <>
152 | |
153 | JA
154 | {title.ja}
155 |
156 | )}
157 |
158 | ),
159 | },
160 | {
161 | title: '曲师',
162 | dataIndex: 'artist',
163 | key: 'artist',
164 | width: 200,
165 | ellipsis: true,
166 | sorter: (a, b) => a.artist.localeCompare(b.artist, 'ja'),
167 | sortDirections: ['ascend', 'descend'],
168 | },
169 | {
170 | title: '谱面',
171 | dataIndex: 'difficulties',
172 | key: 'difficulties',
173 | width: 100,
174 | filters: [
175 | {
176 | text: 'Past',
177 | value: 0,
178 | },
179 | {
180 | text: 'Present',
181 | value: 1,
182 | },
183 | {
184 | text: 'Future',
185 | value: 2,
186 | },
187 | {
188 | text: 'Beyond',
189 | value: 3,
190 | },
191 | ],
192 | filteredValue: filteredInfo.difficulties || null,
193 | onFilter: (value, record) =>
194 | record.difficulties.filter((x) => x.ratingClass === value).length > 0,
195 | // TODO 可选不同难度的谱面难度排序
196 | sorter: (a, b) => {
197 | function levelNormalizer(diff: SongDifficulty) {
198 | return (
199 | // diff.ratingClass * 1000 +
200 | diff.rating * 10 + (diff.ratingPlus ? 5 : 0)
201 | );
202 | }
203 |
204 | const lvA = a.difficulties.map(levelNormalizer);
205 | const lvB = b.difficulties.map(levelNormalizer);
206 |
207 | // 如果有筛选，从筛选条件的最高难度和歌曲拥有的最高难度之间选择较低的一个难度分级进行排序
208 | if (filteredInfo.difficulties) {
209 | const highestRatingClass = filteredInfo.difficulties[
210 | filteredInfo.difficulties.length - 1
211 | ] as number;
212 | return (
213 | lvA[Math.min(highestRatingClass, lvA.length - 1)] -
214 | lvB[Math.min(highestRatingClass, lvB.length - 1)]
215 | );
216 | }
217 | // 否则直接按照歌曲最高难度排序
218 | return lvA[lvA.length - 1] - lvB[lvB.length - 1];
219 | },
220 | render: (diffs: SongDifficulty[]) => {
221 | return diffs.map((diff) => {
222 | if (diff.rating < 0) return <>;
223 | if (
224 | filteredInfo.difficulties &&
225 | !filteredInfo.difficulties.includes(diff.ratingClass)
226 | )
227 | return <>;
228 | return (
229 |
234 |
237 | {convertRatingClass(diff.ratingClass)}{' '}
238 | {diff.rating === 0 ? '?' : diff.rating}
239 | {diff.ratingPlus ? '+' : ''}
240 |
241 |
242 | );
243 | });
244 | },
245 | },
246 | {
247 | title: 'BPM',
248 | dataIndex: 'bpm_combine',
249 | key: 'bpm_combine',
250 | width: 120,
251 | ellipsis: true,
252 | sorter: (a, b) => a.bpm_base - b.bpm_base,
253 | sortDirections: ['ascend', 'descend'],
254 | },
255 | {
256 | title: '曲包',
257 | dataIndex: 'set',
258 | key: 'set',
259 | width: 100,
260 | sorter: (a, b) => a.set.localeCompare(b.set),
261 | sortDirections: ['ascend', 'descend'],
262 | },
263 | {
264 | title: '侧',
265 | dataIndex: 'side',
266 | key: 'side',
267 | width: 80,
268 | filters: [
269 | {
270 | text: '光芒',
271 | value: 0,
272 | },
273 | {
274 | text: '纷争',
275 | value: 1,
276 | },
277 | {
278 | text: '消色',
279 | value: 2,
280 | },
281 | ],
282 | onFilter: (value, record) => record.side === value,
283 | filteredValue: filteredInfo.side || null,
284 | render: (side) => {
285 | if (side === 0) {
286 | return 光芒;
287 | }
288 | if (side === 1) {
289 | return 纷争;
290 | }
291 | if (side === 2) {
292 | return 消色;
293 | }
294 | return <>;
295 | },
296 | },
297 | {
298 | title: '背景',
299 | dataIndex: 'bg',
300 | key: 'bg',
301 | width: 150,
302 | ellipsis: true,
303 | sorter: (a, b) => a.bg.localeCompare(b.bg),
304 | sortDirections: ['ascend', 'descend'],
305 | },
306 | {
307 | title: '日期',
308 | dataIndex: 'date',
309 | key: 'date',
310 | width: 150,
311 | sorter: (a, b) => a.date - b.date,
312 | sortDirections: ['ascend', 'descend'],
313 | render: (date) => (
314 | {new Date(date * 1000).toLocaleString()}
315 | ),
316 | },
317 | {
318 | title: '版本',
319 | dataIndex: 'version',
320 | key: 'version',
321 | width: 80,
322 | sorter: (a, b) => a.version.localeCompare(b.version),
323 | sortDirections: ['ascend', 'descend'],
324 | },
325 | ];
326 |
327 | const assetsSongsFilteredBySettings: Song[] =
328 | assets.songs && Array.isArray(assets.songs)
329 | ? assets.songs
330 | .filter((song) => !settings.ignoredSong.split(',').includes(song.id))
331 | .map((song) => ({
332 | ...song,
333 | difficulties: song.difficulties.filter(
334 | (dif) => dif.rating >= settings.minimalRating
335 | ),
336 | }))
337 | : [];
338 |
339 | let data: SongTableData[] = [];
340 | if (assetsSongsFilteredBySettings) {
341 | data = assetsSongsFilteredBySettings.map((song, index) => ({
342 | key: song.id,
343 | title: song.title_localized.ja ?? song.title_localized.en,
344 | bpm_combine: `${song.bpm.split('\n')[0]} (${song.bpm_base})`,
345 | idWithExtFlag: {
346 | id: song.id,
347 | ext: song._external,
348 | },
349 | ...song,
350 | }));
351 | }
352 |
353 | const [searchValue, setSearchValue] = useState('');
354 | const filteredData = data.filter((song) => {
355 | const cons = searchValue.split(' ');
356 |
357 | function parseCon(con: string): boolean {
358 | if (con.length === 0) return true;
359 |
360 | if (song.id.toLocaleLowerCase().includes(con.toLocaleLowerCase()))
361 | return true;
362 | if (
363 | song.title_localized.en
364 | .toLocaleLowerCase()
365 | .includes(con.toLocaleLowerCase())
366 | )
367 | return true;
368 | if (
369 | song.title_localized.ja
370 | ?.toLocaleLowerCase()
371 | ?.includes(con.toLocaleLowerCase())
372 | )
373 | return true;
374 | if (song.artist.toLocaleLowerCase().includes(con.toLocaleLowerCase()))
375 | return true;
376 | if (song.set.toLocaleLowerCase().includes(con.toLocaleLowerCase()))
377 | return true;
378 | if (song.bg.toLocaleLowerCase().includes(con.toLocaleLowerCase()))
379 | return true;
380 | if (song.version.toLocaleLowerCase().includes(con.toLocaleLowerCase()))
381 | return true;
382 |
383 | function shortDiffNameToRatingClass(name: string) {
384 | switch (name) {
385 | case 'pst':
386 | return 0;
387 | case 'prs':
388 | return 1;
389 | case 'ftr':
390 | return 2;
391 | case 'byd':
392 | return 3;
393 | default:
394 | return -1;
395 | }
396 | }
397 | if (
398 | (con.startsWith('pst') ||
399 | con.startsWith('prs') ||
400 | con.startsWith('ftr') ||
401 | con.startsWith('byd') ||
402 | con.startsWith('any')) &&
403 | song.difficulties.filter(
404 | (diff) =>
405 | diff.rating ===
406 | +(con.endsWith('+')
407 | ? con.substring(3, con.length - 1)
408 | : con.substring(3, con.length)) &&
409 | (diff.ratingPlus
410 | ? diff.ratingPlus === con.endsWith('+')
411 | : con.endsWith('+') === false) &&
412 | (con.startsWith('any')
413 | ? true
414 | : diff.ratingClass ===
415 | shortDiffNameToRatingClass(con.substring(0, 3)))
416 | ).length > 0
417 | )
418 | return true;
419 |
420 | return false;
421 | }
422 |
423 | const result = cons.map(parseCon).reduce((a, b) => a && b);
424 |
425 | return result;
426 | });
427 |
428 | const [selectedRowKeys, setSelectedRowKeys] = useState([]);
429 |
430 | const onSelectChange = (newSelectedRowKeys: React.Key[]) => {
431 | console.log('selectedRowKeys changed: ', newSelectedRowKeys);
432 | setSelectedRowKeys(newSelectedRowKeys);
433 | };
434 |
435 | const rowSelection: TableRowSelection = {
436 | selectedRowKeys,
437 | onChange: onSelectChange,
438 | };
439 |
440 | const [loading, setLoading] = useState(false);
441 | const [log, setLog] = useState('');
442 |
443 | const themeToken = theme.useToken();
444 |
445 | const refreshButtonClickHandler = async () => {
446 | const songsResp = await window.aam.ipcRenderer.loadSongs(assets.path);
447 | if (songsResp.code === 0) {
448 | messageApi.success('已刷新');
449 | dispatch(setSongs(songsResp.data));
450 | } else {
451 | messageApi.error(songsResp.message);
452 | }
453 | };
454 |
455 | const reverseSelectButtonClickHandler = async () => {
456 | const newSelectedRowKeys = filteredData
457 | .map((row) => row.key)
458 | .filter((key) => !selectedRowKeys.includes(key));
459 | setSelectedRowKeys(newSelectedRowKeys);
460 | };
461 |
462 | const [editJsonModalOpen, setEditJsonModalOpen] = useState(false);
463 | const [editJsonModalContent, setEditJsonModalContent] = useState('');
464 | const [editorMarkers, setEditorMarkers] = useState([]);
465 | const editorNoError = editorMarkers.length === 0;
466 | const parsedMarkers = editorMarkers
467 | .map((marker) => {
468 | return `${marker.message} [Ln ${marker.startLineNumber}, Col ${marker.startColumn}];`;
469 | })
470 | .join('\n');
471 | const editorRef = useRef(null);
472 |
473 | function handleEditorDidMount(editor, monaco) {
474 | editorRef.current = editor;
475 | }
476 | const editJsonButtonClickHandler = async () => {
477 | if (assets.songs && Array.isArray(assets.songs)) {
478 | setEditJsonModalContent(
479 | JSON.stringify(
480 | {
481 | songs: assets.songs.filter((song) =>
482 | selectedRowKeys.includes(song.id)
483 | ),
484 | },
485 | undefined,
486 | 2
487 | )
488 | );
489 | }
490 | setEditJsonModalOpen(true);
491 | };
492 | const editJsonModalOkHandler = async () => {
493 | const submitContent = editorRef.current!.getValue();
494 | console.log('submit content', submitContent);
495 | try {
496 | const songlistPatch = JSON.parse(submitContent) as { songs: Song[] };
497 | console.log('songlist patch:', songlistPatch);
498 |
499 | const indexedSonglistPatch = songlistPatch.songs.map((song, index) => {
500 | const correspondIndex = assets.songs?.findIndex((sourceSong) => {
501 | return sourceSong.id === song.id;
502 | });
503 | console.log(correspondIndex);
504 | if (correspondIndex !== undefined && correspondIndex > -1) {
505 | return { correspondIndex, song };
506 | }
507 | return null;
508 | });
509 |
510 | console.log('indexedSonglistPatch', indexedSonglistPatch);
511 |
512 | if (assets.songs) {
513 | const patchedSonglist = assets.songs.map((sourceSong, index) => {
514 | for (const patchSongStruct of indexedSonglistPatch) {
515 | if (patchSongStruct && patchSongStruct.correspondIndex === index) {
516 | return patchSongStruct.song;
517 | }
518 | }
519 | return sourceSong;
520 | });
521 |
522 | const saveSonglistResp = await window.aam.ipcRenderer.saveSonglist({
523 | songs: patchedSonglist,
524 | });
525 |
526 | console.log('patched: ', patchedSonglist);
527 |
528 | if (saveSonglistResp.code === 0) {
529 | messageApi.success('已保存');
530 | // window.aam.ipcRenderer.loadSongs(assets.path);
531 | refreshButtonClickHandler();
532 | setEditJsonModalOpen(false);
533 | } else {
534 | messageApi.error(saveSonglistResp.message);
535 | }
536 | }
537 | } catch (e: Error) {
538 | if (e.name === 'SyntaxError') {
539 | messageApi.error(`JSON格式错误`);
540 | } else {
541 | messageApi.error(`未知错误：${e.name}`);
542 | }
543 | }
544 | };
545 | const editJsonModalCancelHandler = () => {
546 | setEditJsonModalContent('');
547 | setEditorMarkers([]);
548 | setEditJsonModalOpen(false);
549 | };
550 | function handleEditorValidation(markers) {
551 | // model markers
552 | setEditorMarkers(markers);
553 | console.log(markers);
554 | }
555 |
556 | const [deleteModalOpen, setDeleteModalOpen] = useState(false);
557 | const deleteModalOkButtonClickHandler = async () => {
558 | if (assets.songs) {
559 | const patchedSonglist = assets.songs.filter((song, index) => {
560 | if (selectedRowKeys.includes(song.id)) {
561 | return false;
562 | }
563 | return true;
564 | });
565 |
566 | const mergedResults = await Promise.allSettled([
567 | window.aam.ipcRenderer.saveSonglist({
568 | songs: patchedSonglist,
569 | }),
570 | window.aam.ipcRenderer.deleteSongs(selectedRowKeys as string[]),
571 | ]);
572 |
573 | console.log(mergedResults);
574 | const isAllResultsOk = mergedResults
575 | .map((result) => {
576 | return result.status === 'rejected' ? 1 : result.value.code;
577 | })
578 | .reduce((a, b) => a + b);
579 | if (isAllResultsOk === 0) {
580 | messageApi.success('已保存');
581 | // window.aam.ipcRenderer.loadSongs(assets.path);
582 | refreshButtonClickHandler();
583 | setDeleteModalOpen(false);
584 | } else {
585 | messageApi.error('遇到了未知错误');
586 | }
587 | }
588 | };
589 |
590 | const unlinkButtonClickHandler = async () => {
591 | if (assets.songs) {
592 | const patchedSonglist = assets.songs.map((song, index) => {
593 | if (selectedRowKeys.includes(song.id) && song._external) {
594 | return { ...song, _external: undefined };
595 | }
596 | return song;
597 | });
598 |
599 | const saveSonglistResp = await window.aam.ipcRenderer.saveSonglist({
600 | songs: patchedSonglist,
601 | });
602 |
603 | console.log('patched: ', patchedSonglist);
604 |
605 | if (saveSonglistResp.code === 0) {
606 | messageApi.success('已保存');
607 | // window.aam.ipcRenderer.loadSongs(assets.path);
608 | refreshButtonClickHandler();
609 | setEditJsonModalOpen(false);
610 | } else {
611 | messageApi.error(saveSonglistResp.message);
612 | }
613 | }
614 | };
615 |
616 | useEffect(() => {
617 | window.aam.ipcRenderer.onStartGeneratePackage(() => {
618 | setLog('');
619 | setLoading(true);
620 | });
621 | window.aam.ipcRenderer.onStopGeneratePackage(() => {
622 | setLoading(false);
623 | setLog('');
624 | });
625 | window.aam.ipcRenderer.onLog((_, args) => {
626 | setLog(args);
627 | });
628 | }, []);
629 |
630 | return (
631 | <>
632 | {contextHolder}
633 |
634 |
641 |
642 |
649 |
657 |
666 |
674 |
683 |
692 |
701 |
702 |
}
705 | allowClear
706 | style={{ width: '250px' }}
707 | value={searchValue}
708 | placeholder="例：base ftr9+/any11"
709 | onChange={(e) => {
710 | setSearchValue(e.target.value);
711 | }}
712 | />
713 |
714 |
715 |
725 |
784 | {selectedRowKeys.map((id) => (
785 | <>
786 | {id}
787 |
788 |
789 | ))}
790 |
791 | 此操作不能撤销。
792 |
793 |
794 |
795 | );
796 | };
797 |
798 | export default Songs;
799 |
--------------------------------------------------------------------------------
/.erb/img/palette-sponsor-banner.svg:
--------------------------------------------------------------------------------
1 |
7 |
--------------------------------------------------------------------------------