antebudimir/feishin
1
0
Fork 0
mirror of https://github.com/antebudimir/feishin.git synced 2026-01-01 18:33:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge pull request #933 from jeffvli/experimental/vite

Browse source 
Migrate from Webpack to Vite
This commit is contained in:
Jeff 2025-05-26 18:10:48 -07:00 • committed by GitHub
commit ec625c2c65
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
486 changed files with 17661 additions and 51682 deletions
Download patch file Download diff file Expand all files Collapse all files

11
.editorconfig
View file

@ -1,12 +1,9 @@
root = true root = true
[*] [*]
indent_style = space
indent_size = 4
end_of_line = lf
charset = utf-8 charset = utf-8
trim_trailing_whitespace = true indent_style = space
indent_size = 2
end_of_line = lf
insert_final_newline = true insert_final_newline = true
trim_trailing_whitespace = true
[*.md]
trim_trailing_whitespace = false

7
.erb/configs/.eslintrc
View file

@ -1,7 +0,0 @@
{
"rules": {
"no-console": "off",
"global-require": "off",
"import/no-dynamic-require": "off"
}
}

64
.erb/configs/webpack.config.base.ts
View file

@ -1,64 +0,0 @@
/**
* Base webpack config used across other specific configs
*/
import webpack from 'webpack';
import { dependencies as externals } from '../../release/app/package.json';
import webpackPaths from './webpack.paths';
import { TsconfigPathsPlugin } from 'tsconfig-paths-webpack-plugin';
const createStyledComponentsTransformer = require('typescript-plugin-styled-components').default;
const styledComponentsTransformer = createStyledComponentsTransformer();
const configuration: webpack.Configuration = {
externals: [...Object.keys(externals || {})],
module: {
rules: [
{
exclude: /node_modules/,
test: /\.[jt]sx?$/,
use: {
loader: 'ts-loader',
options: {
// Remove this line to enable type checking in webpack builds
transpileOnly: true,
getCustomTransformers: () => ({ before: [styledComponentsTransformer] }),
},
},
},
],
},
output: {
// https://github.com/webpack/webpack/issues/1114
library: {
type: 'commonjs2',
},
path: webpackPaths.srcPath,
},
plugins: [
new webpack.EnvironmentPlugin({
NODE_ENV: 'production',
}),
],
/**
* Determine the array of extensions that should be used to resolve modules.
*/
resolve: {
extensions: ['.js', '.jsx', '.json', '.ts', '.tsx'],
fallback: {
child_process: false,
},
plugins: [new TsconfigPathsPlugin({ baseUrl: webpackPaths.srcPath })],
modules: [webpackPaths.srcPath, 'node_modules'],
},
stats: 'errors-only',
};
export default configuration;

3
.erb/configs/webpack.config.eslint.ts
View file

@ -1,3 +0,0 @@
/* eslint import/no-unresolved: off, import/no-self-import: off */
module.exports = require('./webpack.config.renderer.dev').default;

84
.erb/configs/webpack.config.main.prod.ts
View file

@ -1,84 +0,0 @@
/**
* Webpack config for production electron main process
*/
import path from 'path';
import TerserPlugin from 'terser-webpack-plugin';
import webpack from 'webpack';
import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import deleteSourceMaps from '../scripts/delete-source-maps';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
checkNodeEnv('production');
deleteSourceMaps();
const devtoolsConfig =
process.env.DEBUG_PROD === 'true'
? {
devtool: 'source-map',
}
: {};
const configuration: webpack.Configuration = {
...devtoolsConfig,
mode: 'production',
target: 'electron-main',
entry: {
main: path.join(webpackPaths.srcMainPath, 'main.ts'),
preload: path.join(webpackPaths.srcMainPath, 'preload.ts'),
},
output: {
path: webpackPaths.distMainPath,
filename: '[name].js',
},
optimization: {
minimizer: [
new TerserPlugin({
parallel: true,
}),
],
},
plugins: [
new BundleAnalyzerPlugin({
analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
}),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'production',
DEBUG_PROD: false,
START_MINIMIZED: false,
}),
],
/**
* Disables webpack processing of __dirname and __filename.
* If you run the bundle in node.js it falls back to these values of node.js.
* https://github.com/webpack/webpack/issues/2010
*/
node: {
__dirname: false,
__filename: false,
},
};
export default merge(baseConfig, configuration);

70
.erb/configs/webpack.config.preload.dev.ts
View file

@ -1,70 +0,0 @@
import path from 'path';
import webpack from 'webpack';
import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
// at the dev webpack config is not accidentally run in a production environment
if (process.env.NODE_ENV === 'production') {
checkNodeEnv('development');
}
const configuration: webpack.Configuration = {
devtool: 'inline-source-map',
mode: 'development',
target: 'electron-preload',
entry: path.join(webpackPaths.srcMainPath, 'preload.ts'),
output: {
path: webpackPaths.dllPath,
filename: 'preload.js',
},
plugins: [
new BundleAnalyzerPlugin({
analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
}),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*
* By default, use 'development' as NODE_ENV. This can be overriden with
* 'staging', for example, by changing the ENV variables in the npm scripts
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
}),
new webpack.LoaderOptionsPlugin({
debug: true,
}),
],
/**
* Disables webpack processing of __dirname and __filename.
* If you run the bundle in node.js it falls back to these values of node.js.
* https://github.com/webpack/webpack/issues/2010
*/
node: {
__dirname: false,
__filename: false,
},
watch: true,
};
export default merge(baseConfig, configuration);

127
.erb/configs/webpack.config.remote.dev.ts
View file

@ -1,127 +0,0 @@
import 'webpack-dev-server';
import path from 'path';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import webpack from 'webpack';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
const { version } = require('../../package.json');
// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
// at the dev webpack config is not accidentally run in a production environment
if (process.env.NODE_ENV === 'production') {
checkNodeEnv('development');
}
const configuration: webpack.Configuration = {
devtool: 'inline-source-map',
mode: 'development',
target: ['web'],
entry: {
remote: path.join(webpackPaths.srcRemotePath, 'index.tsx'),
worker: path.join(webpackPaths.srcRemotePath, 'service-worker.ts'),
},
output: {
path: webpackPaths.dllPath,
publicPath: '/',
filename: '[name].js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?css$/,
use: [
'style-loader',
{
loader: 'css-loader',
options: {
modules: true,
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?css$/,
use: ['style-loader', 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
plugins: [
new webpack.NoEmitOnErrorsPlugin(),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*
* By default, use 'development' as NODE_ENV. This can be overriden with
* 'staging', for example, by changing the ENV variables in the npm scripts
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
}),
new webpack.LoaderOptionsPlugin({
debug: true,
}),
new HtmlWebpackPlugin({
filename: path.join('index.html'),
template: path.join(webpackPaths.srcRemotePath, 'index.ejs'),
favicon: path.join(webpackPaths.assetsPath, 'icons', 'favicon.ico'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: true,
env: process.env.NODE_ENV,
isDevelopment: process.env.NODE_ENV !== 'production',
nodeModules: webpackPaths.appNodeModulesPath,
templateParameters: {
version,
prod: false,
},
}),
],
node: {
__dirname: false,
__filename: false,
},
watch: true,
};
export default merge(baseConfig, configuration);

142
.erb/configs/webpack.config.remote.prod.ts
View file

@ -1,142 +0,0 @@
/**
* Build config for electron renderer process
*/
import path from 'path';
import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import MiniCssExtractPlugin from 'mini-css-extract-plugin';
import TerserPlugin from 'terser-webpack-plugin';
import webpack from 'webpack';
import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import deleteSourceMaps from '../scripts/delete-source-maps';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
const { version } = require('../../package.json');
checkNodeEnv('production');
deleteSourceMaps();
const devtoolsConfig =
process.env.DEBUG_PROD === 'true'
? {
devtool: 'source-map',
}
: {};
const configuration: webpack.Configuration = {
...devtoolsConfig,
mode: 'production',
target: ['web'],
entry: {
remote: path.join(webpackPaths.srcRemotePath, 'index.tsx'),
worker: path.join(webpackPaths.srcRemotePath, 'service-worker.ts'),
},
output: {
path: webpackPaths.distRemotePath,
publicPath: './',
filename: '[name].js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?(a|c)ss$/,
use: [
MiniCssExtractPlugin.loader,
{
loader: 'css-loader',
options: {
modules: true,
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?(a|c)ss$/,
use: [MiniCssExtractPlugin.loader, 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
optimization: {
minimize: true,
minimizer: [
new TerserPlugin({
parallel: true,
}),
new CssMinimizerPlugin(),
],
},
plugins: [
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'production',
DEBUG_PROD: false,
}),
new MiniCssExtractPlugin({
filename: 'remote.css',
}),
new BundleAnalyzerPlugin({
analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
}),
new HtmlWebpackPlugin({
filename: 'index.html',
template: path.join(webpackPaths.srcRemotePath, 'index.ejs'),
favicon: path.join(webpackPaths.assetsPath, 'icons', 'favicon.ico'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: true,
env: process.env.NODE_ENV,
isDevelopment: process.env.NODE_ENV !== 'production',
templateParameters: {
version,
prod: true,
},
}),
],
};
export default merge(baseConfig, configuration);

79
.erb/configs/webpack.config.renderer.dev.dll.ts
View file

@ -1,79 +0,0 @@
/**
* Builds the DLL for development electron renderer process
*/
import path from 'path';
import webpack from 'webpack';
import { merge } from 'webpack-merge';
import { dependencies } from '../../package.json';
import checkNodeEnv from '../scripts/check-node-env';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
checkNodeEnv('development');
const dist = webpackPaths.dllPath;
const configuration: webpack.Configuration = {
context: webpackPaths.rootPath,
devtool: 'eval',
mode: 'development',
target: 'electron-renderer',
externals: ['fsevents', 'crypto-browserify'],
/**
* Use `module` from `webpack.config.renderer.dev.js`
*/
module: require('./webpack.config.renderer.dev').default.module,
entry: {
renderer: Object.keys(dependencies || {}),
},
output: {
path: dist,
filename: '[name].dev.dll.js',
library: {
name: 'renderer',
type: 'var',
},
},
plugins: [
new webpack.DllPlugin({
path: path.join(dist, '[name].json'),
name: '[name]',
}),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
}),
new webpack.LoaderOptionsPlugin({
debug: true,
options: {
context: webpackPaths.srcPath,
output: {
path: webpackPaths.dllPath,
},
},
}),
],
};
export default merge(baseConfig, configuration);

201
.erb/configs/webpack.config.renderer.dev.ts
View file

@ -1,201 +0,0 @@
import 'webpack-dev-server';
import { execSync, spawn } from 'child_process';
import fs from 'fs';
import path from 'path';
import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin';
import chalk from 'chalk';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import webpack from 'webpack';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
// at the dev webpack config is not accidentally run in a production environment
if (process.env.NODE_ENV === 'production') {
checkNodeEnv('development');
}
const port = process.env.PORT || 4343;
const manifest = path.resolve(webpackPaths.dllPath, 'renderer.json');
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const requiredByDLLConfig = module.parent!.filename.includes('webpack.config.renderer.dev.dll');
/**
* Warn if the DLL is not built
*/
if (!requiredByDLLConfig && !(fs.existsSync(webpackPaths.dllPath) && fs.existsSync(manifest))) {
console.log(
chalk.black.bgYellow.bold(
'The DLL files are missing. Sit back while we build them for you with "npm run build-dll"',
),
);
execSync('npm run postinstall');
}
const configuration: webpack.Configuration = {
devtool: 'inline-source-map',
mode: 'development',
target: ['web', 'electron-renderer'],
entry: [
`webpack-dev-server/client?http://localhost:${port}/dist`,
'webpack/hot/only-dev-server',
path.join(webpackPaths.srcRendererPath, 'index.tsx'),
],
output: {
path: webpackPaths.distRendererPath,
publicPath: '/',
filename: 'renderer.dev.js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?css$/,
use: [
'style-loader',
{
loader: 'css-loader',
options: {
modules: {
localIdentName: '[name]__[local]--[hash:base64:5]',
exportLocalsConvention: 'camelCaseOnly',
},
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?css$/,
use: ['style-loader', 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
plugins: [
...(requiredByDLLConfig
? []
: [
new webpack.DllReferencePlugin({
context: webpackPaths.dllPath,
manifest: require(manifest),
sourceType: 'var',
}),
]),
new webpack.NoEmitOnErrorsPlugin(),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*
* By default, use 'development' as NODE_ENV. This can be overriden with
* 'staging', for example, by changing the ENV variables in the npm scripts
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
}),
new webpack.LoaderOptionsPlugin({
debug: true,
}),
new ReactRefreshWebpackPlugin(),
new HtmlWebpackPlugin({
filename: path.join('index.html'),
template: path.join(webpackPaths.srcRendererPath, 'index.ejs'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: false,
env: process.env.NODE_ENV,
isDevelopment: process.env.NODE_ENV !== 'production',
nodeModules: webpackPaths.appNodeModulesPath,
templateParameters: {
web: false,
},
}),
],
node: {
__dirname: false,
__filename: false,
},
devServer: {
port,
compress: true,
hot: true,
headers: { 'Access-Control-Allow-Origin': '*' },
static: {
publicPath: '/',
},
historyApiFallback: {
verbose: true,
},
setupMiddlewares(middlewares) {
console.log('Starting preload.js builder...');
const preloadProcess = spawn('npm', ['run', 'start:preload'], {
shell: true,
stdio: 'inherit',
})
.on('close', (code: number) => process.exit(code!))
.on('error', (spawnError) => console.error(spawnError));
console.log('Starting remote.js builder...');
const remoteProcess = spawn('npm', ['run', 'start:remote'], {
shell: true,
stdio: 'inherit',
})
.on('close', (code: number) => process.exit(code!))
.on('error', (spawnError) => console.error(spawnError));
console.log('Starting Main Process...');
spawn('npm', ['run', 'start:main'], {
shell: true,
stdio: 'inherit',
})
.on('close', (code: number) => {
preloadProcess.kill();
remoteProcess.kill();
process.exit(code!);
})
.on('error', (spawnError) => console.error(spawnError));
return middlewares;
},
},
};
export default merge(baseConfig, configuration);

137
.erb/configs/webpack.config.renderer.prod.ts
View file

@ -1,137 +0,0 @@
/**
* Build config for electron renderer process
*/
import path from 'path';
import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import MiniCssExtractPlugin from 'mini-css-extract-plugin';
import TerserPlugin from 'terser-webpack-plugin';
import webpack from 'webpack';
import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import deleteSourceMaps from '../scripts/delete-source-maps';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
checkNodeEnv('production');
deleteSourceMaps();
const devtoolsConfig =
process.env.DEBUG_PROD === 'true'
? {
devtool: 'source-map',
}
: {};
const configuration: webpack.Configuration = {
...devtoolsConfig,
mode: 'production',
target: ['web', 'electron-renderer'],
entry: [path.join(webpackPaths.srcRendererPath, 'index.tsx')],
output: {
path: webpackPaths.distRendererPath,
publicPath: './',
filename: 'renderer.js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?(a|c)ss$/,
use: [
MiniCssExtractPlugin.loader,
{
loader: 'css-loader',
options: {
modules: {
localIdentName: '[name]__[local]--[hash:base64:5]',
exportLocalsConvention: 'camelCaseOnly',
},
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?(a|c)ss$/,
use: [MiniCssExtractPlugin.loader, 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
optimization: {
minimize: true,
minimizer: [
new TerserPlugin({
parallel: true,
}),
new CssMinimizerPlugin(),
],
},
plugins: [
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'production',
DEBUG_PROD: false,
}),
new MiniCssExtractPlugin({
filename: 'style.css',
}),
new BundleAnalyzerPlugin({
analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
}),
new HtmlWebpackPlugin({
filename: 'index.html',
template: path.join(webpackPaths.srcRendererPath, 'index.ejs'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: false,
isDevelopment: process.env.NODE_ENV !== 'production',
templateParameters: {
web: false,
},
}),
],
};
export default merge(baseConfig, configuration);

147
.erb/configs/webpack.config.renderer.web.ts
View file

@ -1,147 +0,0 @@
import 'webpack-dev-server';
import path from 'path';
import ReactRefreshWebpackPlugin from '@pmmmwh/react-refresh-webpack-plugin';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import webpack from 'webpack';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
// When an ESLint server is running, we can't set the NODE_ENV so we'll check if it's
// at the dev webpack config is not accidentally run in a production environment
if (process.env.NODE_ENV === 'production') {
checkNodeEnv('development');
}
const port = process.env.PORT || 4343;
const configuration: webpack.Configuration = {
devtool: 'inline-source-map',
mode: 'development',
target: ['web', 'electron-renderer'],
entry: [
`webpack-dev-server/client?http://localhost:${port}/dist`,
'webpack/hot/only-dev-server',
path.join(webpackPaths.srcRendererPath, 'index.tsx'),
],
output: {
path: webpackPaths.distRendererPath,
publicPath: '/',
filename: 'renderer.dev.js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?css$/,
use: [
'style-loader',
{
loader: 'css-loader',
options: {
modules: {
localIdentName: '[name]__[local]--[hash:base64:5]',
exportLocalsConvention: 'camelCaseOnly',
},
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?css$/,
use: ['style-loader', 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
plugins: [
new webpack.NoEmitOnErrorsPlugin(),
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*
* By default, use 'development' as NODE_ENV. This can be overriden with
* 'staging', for example, by changing the ENV variables in the npm scripts
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'development',
}),
new webpack.LoaderOptionsPlugin({
debug: true,
}),
new ReactRefreshWebpackPlugin(),
new HtmlWebpackPlugin({
filename: path.join('index.html'),
template: path.join(webpackPaths.srcRendererPath, 'index.ejs'),
favicon: path.join(webpackPaths.assetsPath, 'icons', 'favicon.ico'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: false,
env: process.env.NODE_ENV,
isDevelopment: process.env.NODE_ENV !== 'production',
nodeModules: webpackPaths.appNodeModulesPath,
templateParameters: {
web: false, // with hot reload, we don't have NGINX injecting variables
},
}),
],
node: {
__dirname: false,
__filename: false,
},
devServer: {
port,
compress: true,
hot: true,
headers: { 'Access-Control-Allow-Origin': '*' },
static: {
publicPath: '/',
},
historyApiFallback: {
verbose: true,
},
setupMiddlewares(middlewares) {
return middlewares;
},
},
};
export default merge(baseConfig, configuration);

138
.erb/configs/webpack.config.web.prod.ts
View file

@ -1,138 +0,0 @@
/**
* Build config for electron renderer process
*/
import path from 'path';
import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import MiniCssExtractPlugin from 'mini-css-extract-plugin';
import TerserPlugin from 'terser-webpack-plugin';
import webpack from 'webpack';
import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
import { merge } from 'webpack-merge';
import checkNodeEnv from '../scripts/check-node-env';
import deleteSourceMaps from '../scripts/delete-source-maps';
import baseConfig from './webpack.config.base';
import webpackPaths from './webpack.paths';
checkNodeEnv('production');
deleteSourceMaps();
const devtoolsConfig =
process.env.DEBUG_PROD === 'true'
? {
devtool: 'source-map',
}
: {};
const configuration: webpack.Configuration = {
...devtoolsConfig,
mode: 'production',
target: ['web'],
entry: [path.join(webpackPaths.srcRendererPath, 'index.tsx')],
output: {
path: webpackPaths.distWebPath,
publicPath: 'auto',
filename: 'renderer.js',
library: {
type: 'umd',
},
},
module: {
rules: [
{
test: /\.s?(a|c)ss$/,
use: [
MiniCssExtractPlugin.loader,
{
loader: 'css-loader',
options: {
modules: {
localIdentName: '[name]__[local]--[hash:base64:5]',
exportLocalsConvention: 'camelCaseOnly',
},
sourceMap: true,
importLoaders: 1,
},
},
'sass-loader',
],
include: /\.module\.s?(c|a)ss$/,
},
{
test: /\.s?(a|c)ss$/,
use: [MiniCssExtractPlugin.loader, 'css-loader', 'sass-loader'],
exclude: /\.module\.s?(c|a)ss$/,
},
// Fonts
{
test: /\.(woff|woff2|eot|ttf|otf)$/i,
type: 'asset/resource',
},
// Images
{
test: /\.(png|svg|jpg|jpeg|gif)$/i,
type: 'asset/resource',
},
],
},
optimization: {
minimize: true,
minimizer: [
new TerserPlugin({
parallel: true,
}),
new CssMinimizerPlugin(),
],
},
plugins: [
/**
* Create global constants which can be configured at compile time.
*
* Useful for allowing different behaviour between development builds and
* release builds
*
* NODE_ENV should be production so that modules do not perform certain
* development checks
*/
new webpack.EnvironmentPlugin({
NODE_ENV: 'production',
DEBUG_PROD: false,
}),
new MiniCssExtractPlugin({
filename: 'style.css',
}),
new BundleAnalyzerPlugin({
analyzerMode: process.env.ANALYZE === 'true' ? 'server' : 'disabled',
}),
new HtmlWebpackPlugin({
filename: 'index.html',
template: path.join(webpackPaths.srcRendererPath, 'index.ejs'),
favicon: path.join(webpackPaths.assetsPath, 'icons', 'favicon.ico'),
minify: {
collapseWhitespace: true,
removeAttributeQuotes: true,
removeComments: true,
},
isBrowser: false,
isDevelopment: process.env.NODE_ENV !== 'production',
templateParameters: {
web: true,
},
}),
],
};
export default merge(baseConfig, configuration);

46
.erb/configs/webpack.paths.ts
View file

@ -1,46 +0,0 @@
const path = require('path');
const rootPath = path.join(__dirname, '../..');
const dllPath = path.join(__dirname, '../dll');
const srcPath = path.join(rootPath, 'src');
const assetsPath = path.join(rootPath, 'assets');
const srcMainPath = path.join(srcPath, 'main');
const srcRemotePath = path.join(srcPath, 'remote');
const srcRendererPath = path.join(srcPath, 'renderer');
const releasePath = path.join(rootPath, 'release');
const appPath = path.join(releasePath, 'app');
const appPackagePath = path.join(appPath, 'package.json');
const appNodeModulesPath = path.join(appPath, 'node_modules');
const srcNodeModulesPath = path.join(srcPath, 'node_modules');
const distPath = path.join(appPath, 'dist');
const distMainPath = path.join(distPath, 'main');
const distRemotePath = path.join(distPath, 'remote');
const distRendererPath = path.join(distPath, 'renderer');
const distWebPath = path.join(distPath, 'web');
const buildPath = path.join(releasePath, 'build');
export default {
assetsPath,
rootPath,
dllPath,
srcPath,
srcMainPath,
srcRemotePath,
srcRendererPath,
releasePath,
appPath,
appPackagePath,
appNodeModulesPath,
srcNodeModulesPath,
distPath,
distMainPath,
distRemotePath,
distRendererPath,
distWebPath,
buildPath,
};

1
.erb/mocks/fileMock.js
View file

@ -1 +0,0 @@
export default 'test-file-stub';

8
.erb/scripts/.eslintrc
View file

@ -1,8 +0,0 @@
{
"rules": {
"no-console": "off",
"global-require": "off",
"import/no-dynamic-require": "off",
"import/no-extraneous-dependencies": "off"
}
}

33
.erb/scripts/check-build-exists.ts
View file

@ -1,33 +0,0 @@
// Check if the renderer and main bundles are built
import path from 'path';
import chalk from 'chalk';
import fs from 'fs';
import webpackPaths from '../configs/webpack.paths';
const mainPath = path.join(webpackPaths.distMainPath, 'main.js');
const remotePath = path.join(webpackPaths.distMainPath, 'remote.js');
const rendererPath = path.join(webpackPaths.distRendererPath, 'renderer.js');
if (!fs.existsSync(mainPath)) {
throw new Error(
chalk.whiteBright.bgRed.bold(
'The main process is not built yet. Build it by running "npm run build:main"',
),
);
}
if (!fs.existsSync(remotePath)) {
throw new Error(
chalk.whiteBright.bgRed.bold(
'The remote process is not built yet. Build it by running "npm run build:remote"',
),
);
}
if (!fs.existsSync(rendererPath)) {
throw new Error(
chalk.whiteBright.bgRed.bold(
'The renderer process is not built yet. Build it by running "npm run build:renderer"',
),
);
}

54
.erb/scripts/check-native-dep.js
View file

@ -1,54 +0,0 @@
import fs from 'fs';
import chalk from 'chalk';
import { execSync } from 'child_process';
import { dependencies } from '../../package.json';
if (dependencies) {
const dependenciesKeys = Object.keys(dependencies);
const nativeDeps = fs
.readdirSync('node_modules')
.filter((folder) => fs.existsSync(`node_modules/${folder}/binding.gyp`));
if (nativeDeps.length === 0) {
process.exit(0);
}
try {
// Find the reason for why the dependency is installed. If it is installed
// because of a devDependency then that is okay. Warn when it is installed
// because of a dependency
const { dependencies: dependenciesObject } = JSON.parse(
execSync(`npm ls ${nativeDeps.join(' ')} --json`).toString()
);
const rootDependencies = Object.keys(dependenciesObject);
const filteredRootDependencies = rootDependencies.filter((rootDependency) =>
dependenciesKeys.includes(rootDependency)
);
if (filteredRootDependencies.length > 0) {
const plural = filteredRootDependencies.length > 1;
console.log(`
${chalk.whiteBright.bgYellow.bold(
'Webpack does not work with native dependencies.'
)}
${chalk.bold(filteredRootDependencies.join(', '))} ${
plural ? 'are native dependencies' : 'is a native dependency'
} and should be installed inside of the "./release/app" folder.
First, uninstall the packages from "./package.json":
${chalk.whiteBright.bgGreen.bold('npm uninstall your-package')}
${chalk.bold(
'Then, instead of installing the package to the root "./package.json":'
)}
${chalk.whiteBright.bgRed.bold('npm install your-package')}
${chalk.bold('Install the package to "./release/app/package.json"')}
${chalk.whiteBright.bgGreen.bold(
'cd ./release/app && npm install your-package'
)}
Read more about native dependencies at:
${chalk.bold(
'https://electron-react-boilerplate.js.org/docs/adding-dependencies/#module-structure'
)}
`);
process.exit(1);
}
} catch (e) {
console.log('Native dependencies could not be checked');
}
}

16
.erb/scripts/check-node-env.js
View file

@ -1,16 +0,0 @@
import chalk from 'chalk';
export default function checkNodeEnv(expectedEnv) {
if (!expectedEnv) {
throw new Error('"expectedEnv" not set');
}
if (process.env.NODE_ENV !== expectedEnv) {
console.log(
chalk.whiteBright.bgRed.bold(
`"process.env.NODE_ENV" must be "${expectedEnv}" to use this webpack config`
)
);
process.exit(2);
}
}

16
.erb/scripts/check-port-in-use.js
View file

@ -1,16 +0,0 @@
import chalk from 'chalk';
import detectPort from 'detect-port';
const port = process.env.PORT || '4343';
detectPort(port, (err, availablePort) => {
if (port !== String(availablePort)) {
throw new Error(
chalk.whiteBright.bgRed.bold(
`Port "${port}" on "localhost" is already in use. Please use another port. ex: PORT=4343 npm start`
)
);
} else {
process.exit(0);
}
});

17
.erb/scripts/clean.js
View file

@ -1,17 +0,0 @@
import rimraf from 'rimraf';
import process from 'process';
import webpackPaths from '../configs/webpack.paths';
const args = process.argv.slice(2);
const commandMap = {
dist: webpackPaths.distPath,
release: webpackPaths.releasePath,
dll: webpackPaths.dllPath,
};
args.forEach((x) => {
const pathToRemove = commandMap[x];
if (pathToRemove !== undefined) {
rimraf.sync(pathToRemove);
}
});

9
.erb/scripts/delete-source-maps.js
View file

@ -1,9 +0,0 @@
import path from 'path';
import rimraf from 'rimraf';
import webpackPaths from '../configs/webpack.paths';
export default function deleteSourceMaps() {
rimraf.sync(path.join(webpackPaths.distMainPath, '*.js.map'));
rimraf.sync(path.join(webpackPaths.distRemotePath, '*.js.map'));
rimraf.sync(path.join(webpackPaths.distRendererPath, '*.js.map'));
}

20
.erb/scripts/electron-rebuild.js
View file

@ -1,20 +0,0 @@
import { execSync } from 'child_process';
import fs from 'fs';
import { dependencies } from '../../release/app/package.json';
import webpackPaths from '../configs/webpack.paths';
if (
Object.keys(dependencies || {}).length > 0 &&
fs.existsSync(webpackPaths.appNodeModulesPath)
) {
const electronRebuildCmd =
'../../node_modules/.bin/electron-rebuild --force --types prod,dev,optional --module-dir .';
const cmd =
process.platform === 'win32'
? electronRebuildCmd.replace(/\//g, '\\')
: electronRebuildCmd;
execSync(cmd, {
cwd: webpackPaths.appPath,
stdio: 'inherit',
});
}

9
.erb/scripts/link-modules.ts
View file

@ -1,9 +0,0 @@
import fs from 'fs';
import webpackPaths from '../configs/webpack.paths';
const { srcNodeModulesPath } = webpackPaths;
const { appNodeModulesPath } = webpackPaths;
if (!fs.existsSync(srcNodeModulesPath) && fs.existsSync(appNodeModulesPath)) {
fs.symlinkSync(appNodeModulesPath, srcNodeModulesPath, 'junction');
}

30
.erb/scripts/notarize.js
View file

@ -1,30 +0,0 @@
const { notarize } = require('electron-notarize');
const { build } = require('../../package.json');
exports.default = async function notarizeMacos(context) {
const { electronPlatformName, appOutDir } = context;
if (electronPlatformName !== 'darwin') {
return;
}
if (process.env.CI !== 'true') {
console.warn('Skipping notarizing step. Packaging is not running in CI');
return;
}
if (!('APPLE_ID' in process.env && 'APPLE_ID_PASS' in process.env)) {
console.warn(
'Skipping notarizing step. APPLE_ID and APPLE_ID_PASS env variables must be set'
);
return;
}
const appName = context.packager.appInfo.productFilename;
await notarize({
appBundleId: build.appId,
appPath: `${appOutDir}/${appName}.app`,
appleId: process.env.APPLE_ID,
appleIdPassword: process.env.APPLE_ID_PASS,
});
};

34
.eslintignore
View file

@ -1,34 +0,0 @@
# Logs
logs
*.log
# Runtime data
pids
*.pid
*.seed
# Coverage directory used by tools like istanbul
coverage
.eslintcache
# Dependency directory
# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
node_modules
# OSX
.DS_Store
src/i18n
release/app/dist
release/build
.erb/dll
.idea
npm-debug.log.*
*.css.d.ts
*.sass.d.ts
*.scss.d.ts
# eslint ignores hidden directories by default:
# https://github.com/eslint/eslint/issues/8429
!.erb

97
.eslintrc.js
View file

@ -1,97 +0,0 @@
module.exports = {
extends: ['erb', 'plugin:typescript-sort-keys/recommended'],
ignorePatterns: ['.erb/*', 'server'],
parser: '@typescript-eslint/parser',
parserOptions: {
createDefaultProgram: true,
ecmaVersion: 12,
parser: '@typescript-eslint/parser',
project: './tsconfig.json',
sourceType: 'module',
tsconfigRootDir: './',
},
plugins: ['@typescript-eslint', 'import', 'sort-keys-fix'],
rules: {
'@typescript-eslint/naming-convention': 'off',
'@typescript-eslint/no-explicit-any': 'off',
'@typescript-eslint/no-non-null-assertion': 'off',
'@typescript-eslint/no-shadow': ['off'],
'@typescript-eslint/no-unused-vars': ['error'],
'@typescript-eslint/no-use-before-define': ['error'],
'default-case': 'off',
'import/extensions': 'off',
'import/no-absolute-path': 'off',
// A temporary hack related to IDE not resolving correct package.json
'import/no-extraneous-dependencies': 'off',
'import/no-unresolved': 'error',
'import/order': [
'error',
{
alphabetize: {
caseInsensitive: true,
order: 'asc',
},
groups: ['builtin', 'external', 'internal', ['parent', 'sibling']],
'newlines-between': 'never',
pathGroups: [
{
group: 'external',
pattern: 'react',
position: 'before',
},
],
pathGroupsExcludedImportTypes: ['react'],
},
],
'import/prefer-default-export': 'off',
'jsx-a11y/click-events-have-key-events': 'off',
'jsx-a11y/interactive-supports-focus': 'off',
'jsx-a11y/media-has-caption': 'off',
'no-await-in-loop': 'off',
'no-console': 'off',
'no-nested-ternary': 'off',
'no-restricted-syntax': 'off',
'no-shadow': 'off',
'no-underscore-dangle': 'off',
'no-unused-vars': 'off',
'no-use-before-define': 'off',
'prefer-destructuring': 'off',
'react/function-component-definition': 'off',
'react/jsx-filename-extension': [2, { extensions: ['.js', '.jsx', '.ts', '.tsx'] }],
'react/jsx-no-useless-fragment': 'off',
'react/jsx-props-no-spreading': 'off',
'react/jsx-sort-props': [
'error',
{
callbacksLast: true,
ignoreCase: false,
noSortAlphabetically: false,
reservedFirst: true,
shorthandFirst: true,
shorthandLast: false,
},
],
'react/no-array-index-key': 'off',
'react/react-in-jsx-scope': 'off',
'react/require-default-props': 'off',
'sort-keys-fix/sort-keys-fix': 'warn',
},
settings: {
'import/parsers': {
'@typescript-eslint/parser': ['.ts', '.tsx'],
},
'import/resolver': {
// See https://github.com/benmosher/eslint-plugin-import/issues/1396#issuecomment-575727774 for line below
node: {
extensions: ['.js', '.jsx', '.ts', '.tsx'],
},
typescript: {
alwaysTryTypes: true,
project: './tsconfig.json',
},
webpack: {
config: require.resolve('./.erb/configs/webpack.config.eslint.ts'),
},
},
},
};

28
.github/workflows/publish-linux.yml vendored
View file

@ -14,17 +14,15 @@ jobs:
- name: Checkout git repo - name: Checkout git repo
uses: actions/checkout@v1 uses: actions/checkout@v1
- name: Install Node and NPM - name: Install Node and PNPM
uses: actions/setup-node@v1 uses: pnpm/action-setup@v4
with: with:
node-version: 18 version: 9
cache: npm
- name: Install dependencies - name: Install dependencies
run: | run: pnpm install
npm install --legacy-peer-deps
- name: Publish releases - name: Build and Publish releases
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
uses: nick-invision/retry@v2.8.2 uses: nick-invision/retry@v2.8.2
@ -33,12 +31,11 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run postinstall pnpm run package:linux
npm run build pnpm run publish:linux
npm exec electron-builder -- --publish always --linux on_retry_command: pnpm cache delete
on_retry_command: npm cache clean --force
- name: Publish releases (arm64) - name: Build and Publish releases (arm64)
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
uses: nick-invision/retry@v2.8.2 uses: nick-invision/retry@v2.8.2
@ -47,7 +44,6 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run postinstall pnpm run package:linux-arm64
npm run build pnpm run publish:linux-arm64
npm exec electron-builder -- --publish always --arm64 on_retry_command: pnpm cache delete
on_retry_command: npm cache clean --force

19
.github/workflows/publish-macos.yml vendored
View file

@ -14,17 +14,15 @@ jobs:
- name: Checkout git repo - name: Checkout git repo
uses: actions/checkout@v1 uses: actions/checkout@v1
- name: Install Node and NPM - name: Install Node and PNPM
uses: actions/setup-node@v1 uses: pnpm/action-setup@v4
with: with:
node-version: 18 version: 9
cache: npm
- name: Install dependencies - name: Install dependencies
run: | run: pnpm install
npm install --legacy-peer-deps
- name: Publish releases - name: Build and Publish releases
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
uses: nick-invision/retry@v2.8.2 uses: nick-invision/retry@v2.8.2
@ -33,7 +31,6 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run postinstall pnpm run package:mac
npm run build pnpm run publish:mac
npm exec electron-builder -- --publish always --mac on_retry_command: pnpm cache delete
on_retry_command: npm cache clean --force

28
.github/workflows/publish-pr.yml vendored
View file

@ -17,15 +17,13 @@ jobs:
- name: Checkout git repo - name: Checkout git repo
uses: actions/checkout@v3 uses: actions/checkout@v3
- name: Install Node and NPM - name: Install Node and PNPM
uses: actions/setup-node@v3 uses: pnpm/action-setup@v4
with: with:
node-version: 18 version: 9
cache: npm
- name: Install dependencies - name: Install dependencies
run: | run: pnpm install
npm install --legacy-peer-deps
- name: Build for Windows - name: Build for Windows
if: ${{ matrix.os == 'windows-latest' }} if: ${{ matrix.os == 'windows-latest' }}
@ -35,7 +33,7 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run package:pr:windows pnpm run package:win:pr
- name: Build for Linux - name: Build for Linux
if: ${{ matrix.os == 'ubuntu-latest' }} if: ${{ matrix.os == 'ubuntu-latest' }}
@ -45,7 +43,7 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run package:pr:linux pnpm run package:linux:pr
- name: Build for MacOS - name: Build for MacOS
if: ${{ matrix.os == 'macos-latest' }} if: ${{ matrix.os == 'macos-latest' }}
@ -55,41 +53,41 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run package:pr:macos pnpm run package:mac:pr
- name: Zip Windows Binaries - name: Zip Windows Binaries
if: ${{ matrix.os == 'windows-latest' }} if: ${{ matrix.os == 'windows-latest' }}
shell: pwsh shell: pwsh
run: | run: |
Compress-Archive -Path "release/build/*.exe" -DestinationPath "release/build/windows-binaries.zip" -Force Compress-Archive -Path "dist/*.exe" -DestinationPath "dist/windows-binaries.zip" -Force
- name: Zip Linux Binaries - name: Zip Linux Binaries
if: ${{ matrix.os == 'ubuntu-latest' }} if: ${{ matrix.os == 'ubuntu-latest' }}
run: | run: |
zip -r release/build/linux-binaries.zip release/build/*.{AppImage,deb,rpm} zip -r dist/linux-binaries.zip dist/*.{AppImage,deb,rpm}
- name: Zip MacOS Binaries - name: Zip MacOS Binaries
if: ${{ matrix.os == 'macos-latest' }} if: ${{ matrix.os == 'macos-latest' }}
run: | run: |
zip -r release/build/macos-binaries.zip release/build/*.dmg zip -r dist/macos-binaries.zip dist/*.dmg
- name: Upload Windows Binaries - name: Upload Windows Binaries
if: ${{ matrix.os == 'windows-latest' }} if: ${{ matrix.os == 'windows-latest' }}
uses: actions/upload-artifact@v4 uses: actions/upload-artifact@v4
with: with:
name: windows-binaries name: windows-binaries
path: release/build/windows-binaries.zip path: dist/windows-binaries.zip
- name: Upload Linux Binaries - name: Upload Linux Binaries
if: ${{ matrix.os == 'ubuntu-latest' }} if: ${{ matrix.os == 'ubuntu-latest' }}
uses: actions/upload-artifact@v4 uses: actions/upload-artifact@v4
with: with:
name: linux-binaries name: linux-binaries
path: release/build/linux-binaries.zip path: dist/linux-binaries.zip
- name: Upload MacOS Binaries - name: Upload MacOS Binaries
if: ${{ matrix.os == 'macos-latest' }} if: ${{ matrix.os == 'macos-latest' }}
uses: actions/upload-artifact@v4 uses: actions/upload-artifact@v4
with: with:
name: macos-binaries name: macos-binaries
path: release/build/macos-binaries.zip path: dist/macos-binaries.zip

19
.github/workflows/publish-windows.yml vendored
View file

@ -14,17 +14,15 @@ jobs:
- name: Checkout git repo - name: Checkout git repo
uses: actions/checkout@v1 uses: actions/checkout@v1
- name: Install Node and NPM - name: Install Node and PNPM
uses: actions/setup-node@v1 uses: pnpm/action-setup@v4
with: with:
node-version: 18 version: 9
cache: npm
- name: Install dependencies - name: Install dependencies
run: | run: pnpm install
npm install --legacy-peer-deps
- name: Publish releases - name: Build and Publish releases
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
uses: nick-invision/retry@v2.8.2 uses: nick-invision/retry@v2.8.2
@ -33,7 +31,6 @@ jobs:
max_attempts: 3 max_attempts: 3
retry_on: error retry_on: error
command: | command: |
npm run postinstall pnpm run package:win
npm run build pnpm run publish:win
npm exec electron-builder -- --publish always --win on_retry_command: pnpm cache delete
on_retry_command: npm cache clean --force

22
.github/workflows/test.yml vendored
View file

@ -14,21 +14,13 @@ jobs:
- name: Check out Git repository - name: Check out Git repository
uses: actions/checkout@v1 uses: actions/checkout@v1
- name: Install Node.js and NPM - name: Install Node.js and PNPM
uses: actions/setup-node@v2 uses: pnpm/action-setup@v4
with: with:
node-version: 16 version: 9
cache: npm
- name: npm install - name: Install dependencies
run: | run: pnpm install
npm install --legacy-peer-deps
- name: npm test - name: Lint Files
env: run: pnpm run lint
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
npm run lint
npm run package
npm exec tsc
npm test

34
.gitignore vendored
View file

@ -1,31 +1,7 @@
# Logs
logs
*.log
# Runtime data
pids
*.pid
*.seed
# Coverage directory used by tools like istanbul
coverage
.eslintcache
# Dependency directory
# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
node_modules node_modules
dist
# OSX out
.DS_Store .DS_Store
.eslintcache
release/app/dist *.log*
release/build release
.erb/dll
.idea
npm-debug.log.*
*.css.d.ts
*.sass.d.ts
*.scss.d.ts
.env*

4
.husky/pre-commit
View file

@ -1,4 +0,0 @@
#!/bin/sh
. "$(dirname "$0")/_/husky.sh"
npx lint-staged

2
.npmrc Normal file
View file

@ -0,0 +1,2 @@
legacy-peer-deps=true
only-built-dependencies=electron,esbuild

6
.prettierignore Normal file
View file

@ -0,0 +1,6 @@
out
dist
pnpm-lock.yaml
LICENSE.md
tsconfig.json
tsconfig.*.json

22
.prettierrc
View file

@ -1,22 +0,0 @@
{
"printWidth": 100,
"semi": true,
"singleQuote": true,
"tabWidth": 4,
"useTabs": false,
"overrides": [
{
"files": ["**/*.css", "**/*.scss", "**/*.html"],
"options": {
"singleQuote": true
}
}
],
"trailingComma": "all",
"bracketSpacing": true,
"arrowParens": "always",
"proseWrap": "never",
"htmlWhitespaceSensitivity": "strict",
"endOfLine": "lf",
"singleAttributePerLine": true
}

14
.prettierrc.yaml Normal file
View file

@ -0,0 +1,14 @@
singleQuote: true
semi: true
printWidth: 100
tabWidth: 4
trailingComma: all
useTabs: false
arrowParens: always
proseWrap: never
htmlWhitespaceSensitivity: strict
endOfLine: lf
singleAttributePerLine: true
bracketSpacing: true
plugins:
- prettier-plugin-packagejson

9
.vscode/extensions.json vendored
View file

@ -1,10 +1,3 @@
{ {
"recommendations": [ "recommendations": ["dbaeumer.vscode-eslint"]
"dbaeumer.vscode-eslint",
"EditorConfig.EditorConfig",
"stylelint.vscode-stylelint",
"esbenp.prettier-vscode",
"clinyong.vscode-css-modules",
"Huuums.vscode-fast-folder-structure"
]
} }

63
.vscode/launch.json vendored
View file

@ -1,28 +1,39 @@
{ {
"version": "0.2.0", "version": "0.2.0",
"configurations": [ "configurations": [
{ {
"name": "Electron: Main", "name": "Debug Main Process",
"type": "node", "type": "node",
"request": "launch", "request": "launch",
"protocol": "inspector", "cwd": "${workspaceRoot}",
"runtimeExecutable": "npm", "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron-vite",
"runtimeArgs": ["run start:main --inspect=5858 --remote-debugging-port=9223"], "windows": {
"preLaunchTask": "Start Webpack Dev" "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron-vite.cmd"
}, },
{ "runtimeArgs": ["--sourcemap"],
"name": "Electron: Renderer", "env": {
"type": "chrome", "REMOTE_DEBUGGING_PORT": "9222"
"request": "attach", }
"port": 9223, },
"webRoot": "${workspaceFolder}", {
"timeout": 15000 "name": "Debug Renderer Process",
} "port": 9222,
], "request": "attach",
"compounds": [ "type": "chrome",
{ "webRoot": "${workspaceFolder}/src/renderer",
"name": "Electron: All", "timeout": 60000,
"configurations": ["Electron: Main", "Electron: Renderer"] "presentation": {
} "hidden": true
] }
}
],
"compounds": [
{
"name": "Debug All",
"configurations": ["Debug Main Process", "Debug Renderer Process"],
"presentation": {
"order": 1
}
}
]
} }

16
.vscode/settings.json vendored
View file

@ -1,4 +1,13 @@
{ {
"[typescript]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"[javascript]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"[json]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"files.associations": { "files.associations": {
".eslintrc": "jsonc", ".eslintrc": "jsonc",
".prettierrc": "jsonc", ".prettierrc": "jsonc",
@ -9,7 +18,7 @@
{ "directory": "./", "changeProcessCWD": true }, { "directory": "./", "changeProcessCWD": true },
{ "directory": "./server", "changeProcessCWD": true } { "directory": "./server", "changeProcessCWD": true }
], ],
"typescript.tsserver.experimental.enableProjectDiagnostics": true, "typescript.tsserver.experimental.enableProjectDiagnostics": false,
"editor.codeActionsOnSave": { "editor.codeActionsOnSave": {
"source.fixAll.eslint": "explicit", "source.fixAll.eslint": "explicit",
"source.fixAll.stylelint": "explicit", "source.fixAll.stylelint": "explicit",
@ -33,14 +42,15 @@
"npm-debug.log.*": true, "npm-debug.log.*": true,
"test/**/__snapshots__": true, "test/**/__snapshots__": true,
"package-lock.json": true, "package-lock.json": true,
"*.{css,sass,scss}.d.ts": true "*.{css,sass,scss}.d.ts": true,
"out/**/*": true,
"dist/**/*": true
}, },
"i18n-ally.localesPaths": ["src/i18n", "src/i18n/locales"], "i18n-ally.localesPaths": ["src/i18n", "src/i18n/locales"],
"typescript.tsdk": "node_modules\\typescript\\lib", "typescript.tsdk": "node_modules\\typescript\\lib",
"typescript.preferences.importModuleSpecifier": "non-relative", "typescript.preferences.importModuleSpecifier": "non-relative",
"stylelint.validate": ["css", "scss", "typescript", "typescriptreact"], "stylelint.validate": ["css", "scss", "typescript", "typescriptreact"],
"typescript.updateImportsOnFileMove.enabled": "always", "typescript.updateImportsOnFileMove.enabled": "always",
"[typescript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
"[typescriptreact]": { "editor.defaultFormatter": "esbenp.prettier-vscode" }, "[typescriptreact]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
"typescript.format.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces": true, "typescript.format.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces": true,
"folderTemplates.structures": [ "folderTemplates.structures": [

25
.vscode/tasks.json vendored
View file

@ -1,25 +0,0 @@
{
"version": "2.0.0",
"tasks": [
{
"type": "npm",
"label": "Start Webpack Dev",
"script": "start:renderer",
"options": {
"cwd": "${workspaceFolder}"
},
"isBackground": true,
"problemMatcher": {
"owner": "custom",
"pattern": {
"regexp": "____________"
},
"background": {
"activeOnStart": true,
"beginsPattern": "Compiling\\.\\.\\.$",
"endsPattern": "(Compiled successfully|Failed to compile)\\.$"
}
}
}
]
}

11
Dockerfile
View file

@ -2,13 +2,14 @@
FROM node:18-alpine as builder FROM node:18-alpine as builder
WORKDIR /app WORKDIR /app
#Copy package.json first to cache node_modules # Copy package.json first to cache node_modules
COPY package.json package-lock.json . COPY package.json package-lock.json .
# Scripts include electron-specific dependencies, which we don't need
RUN npm install --legacy-peer-deps --ignore-scripts RUN pnpm install
#Copy code and build with cached modules
# Copy code and build with cached modules
COPY . . COPY . .
RUN npm run build:web RUN pnpm run build:web
# --- Production stage # --- Production stage
FROM nginx:alpine-slim FROM nginx:alpine-slim

69
README.md
View file

@ -41,13 +41,13 @@ Rewrite of [Sonixd](https://github.com/jeffvli/sonixd).
## Features ## Features
- [x] MPV player backend - [x] MPV player backend
- [x] Web player backend - [x] Web player backend
- [x] Modern UI - [x] Modern UI
- [x] Scrobble playback to your server - [x] Scrobble playback to your server
- [x] Smart playlist editor (Navidrome) - [x] Smart playlist editor (Navidrome)
- [x] Synchronized and unsynchronized lyrics support - [x] Synchronized and unsynchronized lyrics support
- [ ] [Request a feature](https://github.com/jeffvli/feishin/issues) or [view taskboard](https://github.com/users/jeffvli/projects/5/views/1) - [ ] [Request a feature](https://github.com/jeffvli/feishin/issues) or [view taskboard](https://github.com/users/jeffvli/projects/5/views/1)
## Screenshots ## Screenshots
@ -109,8 +109,8 @@ services:
2. After restarting the app, you will be prompted to select a server. Click the `Open menu` button and select `Manage servers`. Click the `Add server` button in the popup and fill out all applicable details. You will need to enter the full URL to your server, including the protocol and port if applicable (e.g. `https://navidrome.my-server.com` or `http://192.168.0.1:4533`). 2. After restarting the app, you will be prompted to select a server. Click the `Open menu` button and select `Manage servers`. Click the `Add server` button in the popup and fill out all applicable details. You will need to enter the full URL to your server, including the protocol and port if applicable (e.g. `https://navidrome.my-server.com` or `http://192.168.0.1:4533`).
- **Navidrome** - For the best experience, select "Save password" when creating the server and configure the `SessionTimeout` setting in your Navidrome config to a larger value (e.g. 72h). - **Navidrome** - For the best experience, select "Save password" when creating the server and configure the `SessionTimeout` setting in your Navidrome config to a larger value (e.g. 72h).
- **Linux users** - The default password store uses `libsecret`. `kwallet4/5/6` are also supported, but must be explicitly set in Settings > Window > Passwords/secret score. - **Linux users** - The default password store uses `libsecret`. `kwallet4/5/6` are also supported, but must be explicitly set in Settings > Window > Passwords/secret score.
3. _Optional_ - If you want to host Feishin on a subpath (not `/`), then pass in the following environment variable: `PUBLIC_PATH=PATH`. For example, to host on `/feishin`, pass in `PUBLIC_PATH=/feishin`. 3. _Optional_ - If you want to host Feishin on a subpath (not `/`), then pass in the following environment variable: `PUBLIC_PATH=PATH`. For example, to host on `/feishin`, pass in `PUBLIC_PATH=/feishin`.
@ -126,18 +126,18 @@ First thing to do is check that your MPV binary path is correct. Navigate to the
Feishin supports any music server that implements a [Navidrome](https://www.navidrome.org/) or [Jellyfin](https://jellyfin.org/) API. **Subsonic API is not currently supported**. This will likely be added in [later when the new Subsonic API is decided on](https://support.symfonium.app/t/subsonic-servers-participation/1233). Feishin supports any music server that implements a [Navidrome](https://www.navidrome.org/) or [Jellyfin](https://jellyfin.org/) API. **Subsonic API is not currently supported**. This will likely be added in [later when the new Subsonic API is decided on](https://support.symfonium.app/t/subsonic-servers-participation/1233).
- [Navidrome](https://github.com/navidrome/navidrome) - [Navidrome](https://github.com/navidrome/navidrome)
- [Jellyfin](https://github.com/jellyfin/jellyfin) - [Jellyfin](https://github.com/jellyfin/jellyfin)
- Subsonic-compatible servers - Subsonic-compatible servers
- [Airsonic-Advanced](https://github.com/airsonic-advanced/airsonic-advanced) - [Airsonic-Advanced](https://github.com/airsonic-advanced/airsonic-advanced)
- [Ampache](https://ampache.org) - [Ampache](https://ampache.org)
- [Astiga](https://asti.ga/) - [Astiga](https://asti.ga/)
- [Funkwhale](https://www.funkwhale.audio/) - [Funkwhale](https://www.funkwhale.audio/)
- [Gonic](https://github.com/sentriz/gonic) - [Gonic](https://github.com/sentriz/gonic)
- [LMS](https://github.com/epoupon/lms) - [LMS](https://github.com/epoupon/lms)
- [Nextcloud Music](https://apps.nextcloud.com/apps/music) - [Nextcloud Music](https://apps.nextcloud.com/apps/music)
- [Supysonic](https://github.com/spl0k/supysonic) - [Supysonic](https://github.com/spl0k/supysonic)
- More (?) - More (?)
### I have the issue "The SUID sandbox helper binary was found, but is not configured correctly" on Linux ### I have the issue "The SUID sandbox helper binary was found, but is not configured correctly" on Linux
@ -152,9 +152,32 @@ Ubunutu 24.04 specifically introduced breaking changes that affect how namespace
## Development ## Development
Built and tested using Node `v16.15.0`. Built and tested using Node `v23.11.0`.
This project is built off of [electron-react-boilerplate](https://github.com/electron-react-boilerplate/electron-react-boilerplate) v4.6.0. This project is built off of [electron-vite](https://github.com/alex8088/electron-vite)
- `pnpm run dev` - Start the development server
- `pnpm run dev:watch` - Start the development server in watch mode (for main / preload HMR)
- `pnpm run start` - Starts the app in production preview mode
- `pnpm run build` - Builds the app for desktop
- `pnpm run build:electron` - Build the electron app (main, preload, and renderer)
- `pnpm run build:remote` - Build the remote app (remote)
- `pnpm run build:web` - Build the standalone web app (renderer)
- `pnpm run package` - Package the project
- `pnpm run package:dev` - Package the project for development
- `pnpm run package:linux` - Package the project for Linux
- `pnpm run package:mac` - Package the project for Mac
- `pnpm run package:win` - Package the project for Windows
- `pnpm run publish:linux` - Publish the project for Linux
- `pnpm run publish:linux-arm64` - Publish the project for Linux ARM64
- `pnpm run publish:mac` - Publish the project for Mac
- `pnpm run publish:win` - Publish the project for Windows
- `pnpm run typecheck` - Type check the project
- `pnpm run typecheck:node` - Type check the project with tsconfig.node.json
- `pnpm run typecheck:web` - Type check the project with tsconfig.web.json
- `pnpm run lint` - Lint the project
- `pnpm run lint:fix` - Lint the project and fix linting errors
- `pnpm run i18next` - Generate i18n files
## Translation ## Translation

4
assets/entitlements.mac.plist
View file

@ -2,9 +2,11 @@
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"> <plist version="1.0">
<dict> <dict>
<key>com.apple.security.cs.allow-jit</key>
<true/>
<key>com.apple.security.cs.allow-unsigned-executable-memory</key> <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
<true/> <true/>
<key>com.apple.security.cs.allow-jit</key> <key>com.apple.security.cs.allow-dyld-environment-variables</key>
<true/> <true/>
</dict> </dict>
</plist> </plist>

3
dev-app-update.yml Normal file
View file

@ -0,0 +1,3 @@
provider: generic
url: https://example.com/auto-updates
updaterCacheDirName: feishin-updater

75
electron-builder.yml Normal file
View file

@ -0,0 +1,75 @@
appId: org.jeffvli.feishin
productName: Feishin
artifactName: ${productName}-${version}-${os}-setup.${ext}
electronVersion: 35.1.5
directories:
buildResources: assets
files:
- 'out/**/*'
- 'package.json'
extraResources:
- assets/**
asarUnpack:
- resources/**
win:
target:
- zip
- nsis
icon: assets/icons/icon.png
nsis:
shortcutName: ${productName}
uninstallDisplayName: ${productName}
createDesktopShortcut: always
mac:
target:
target: default
arch:
- arm64
- x64
icon: assets/icons/icon.icns
type: distribution
hardenedRuntime: true
entitlements: assets/entitlements.mac.plist
entitlementsInherit: assets/entitlements.mac.plist
gatekeeperAssess: false
notarize: false
dmg:
contents: [{ x: 130, y: 220 }, { x: 410, y: 220, type: link, path: /Applications }]
deb:
depends:
- libgssapi_krb5.so.2
- libavahi-common.so.3
- libavahi-client.so.3
- libkrb5.so.3
- libkrb5support.so.0
- libkeyutils.so.1
- libcups.so.2
rpm:
depends:
- libgssapi_krb5.so.2
- libavahi-common.so.3
- libavahi-client.so.3
- libkrb5.so.3
- libkrb5support.so.0
- libkeyutils.so.1
- libcups.so.2
freebsd:
depends:
- libgssapi_krb5.so.2
- libavahi-common.so.3
- libavahi-client.so.3
- libkrb5.so.3
- libkrb5support.so.0
- libkeyutils.so.1
- libcups.so.2
linux:
target:
- AppImage
- tar.xz
category: AudioVideo;Audio;Player
icon: assets/icons/icon.png
npmRebuild: false
publish:
provider: github
owner: jeffvli
repo: feishin

65
electron.vite.config.ts Normal file
View file

@ -0,0 +1,65 @@
import react from '@vitejs/plugin-react';
import { externalizeDepsPlugin, UserConfig } from 'electron-vite';
import { resolve } from 'path';
import conditionalImportPlugin from 'vite-plugin-conditional-import';
import dynamicImportPlugin from 'vite-plugin-dynamic-import';
import { ViteEjsPlugin } from 'vite-plugin-ejs';
const currentOSEnv = process.platform;
const config: UserConfig = {
main: {
build: {
rollupOptions: {
external: ['source-map-support'],
},
},
define: {
'import.meta.env.IS_LINUX': JSON.stringify(currentOSEnv === 'linux'),
'import.meta.env.IS_MACOS': JSON.stringify(currentOSEnv === 'darwin'),
'import.meta.env.IS_WIN': JSON.stringify(currentOSEnv === 'win32'),
},
plugins: [
externalizeDepsPlugin(),
dynamicImportPlugin(),
conditionalImportPlugin({
currentEnv: currentOSEnv,
envs: ['win32', 'linux', 'darwin'],
}),
],
resolve: {
alias: {
'/@/main': resolve('src/main'),
'/@/shared': resolve('src/shared'),
},
},
},
preload: {
plugins: [externalizeDepsPlugin()],
resolve: {
alias: {
'/@/preload': resolve('src/preload'),
'/@/shared': resolve('src/shared'),
},
},
},
renderer: {
css: {
modules: {
generateScopedName: '[name]__[local]__[hash:base64:5]',
localsConvention: 'camelCase',
},
},
plugins: [react(), ViteEjsPlugin({ web: false })],
resolve: {
alias: {
'/@/i18n': resolve('src/i18n'),
'/@/remote': resolve('src/remote'),
'/@/renderer': resolve('src/renderer'),
'/@/shared': resolve('src/shared'),
},
},
},
};
export default config;

52
eslint.config.mjs Normal file
View file

@ -0,0 +1,52 @@
import eslintConfigPrettier from '@electron-toolkit/eslint-config-prettier';
import tseslint from '@electron-toolkit/eslint-config-ts';
import perfectionist from 'eslint-plugin-perfectionist';
import eslintPluginReact from 'eslint-plugin-react';
import eslintPluginReactHooks from 'eslint-plugin-react-hooks';
import eslintPluginReactRefresh from 'eslint-plugin-react-refresh';
export default tseslint.config(
{ ignores: ['**/node_modules', '**/dist', '**/out'] },
tseslint.configs.recommended,
perfectionist.configs['recommended-natural'],
eslintPluginReact.configs.flat.recommended,
eslintPluginReact.configs.flat['jsx-runtime'],
{
settings: {
react: {
version: 'detect',
},
},
},
{
files: ['**/*.{ts,tsx}'],
plugins: {
'react-hooks': eslintPluginReactHooks,
'react-refresh': eslintPluginReactRefresh,
},
rules: {
...eslintPluginReactHooks.configs.recommended.rules,
...eslintPluginReactRefresh.configs.vite.rules,
'@typescript-eslint/explicit-function-return-type': 'off',
'@typescript-eslint/no-duplicate-enum-values': 'off',
'@typescript-eslint/no-explicit-any': 'off',
'@typescript-eslint/no-unused-vars': 'warn',
curly: ['error', 'all'],
indent: [
'error',
'tab',
{
offsetTernaryExpressions: true,
SwitchCase: 1,
},
],
'no-unused-vars': 'off',
'no-use-before-define': 'off',
quotes: ['error', 'single'],
'react-refresh/only-export-components': 'off',
'react/display-name': 'off',
semi: ['error', 'always'],
},
},
eslintConfigPrettier,
);

27
ng.conf.template
View file

@ -1,27 +0,0 @@
server {
listen 9180;
sendfile on;
default_type application/octet-stream;
gzip on;
gzip_http_version 1.1;
gzip_disable "MSIE [1-6]\.";
gzip_min_length 256;
gzip_vary on;
gzip_proxied expired no-cache no-store private auth;
gzip_types text/plain text/css application/json application/javascript application/x-javascript text/xml application/xml application/xml+rss text/javascript;
gzip_comp_level 9;
location ${PUBLIC_PATH} {
alias /usr/share/nginx/html/;
try_files $uri $uri/ /index.html =404;
}
location ${PUBLIC_PATH}settings.js {
alias /etc/nginx/conf.d/settings.js;
}
location ${PUBLIC_PATH}/settings.js {
alias /etc/nginx/conf.d/settings.js;
}
}

40779
package-lock.json generated
View file

File diff suppressed because it is too large Load diff

428
package.json
View file

@ -1,297 +1,52 @@
{ {
"name": "feishin", "name": "feishin",
"productName": "Feishin", "version": "0.12.7",
"description": "Feishin music server", "description": "A modern self-hosted music player.",
"version": "0.13.0",
"scripts": {
"build": "concurrently \"npm run build:main\" \"npm run build:renderer\" \"npm run build:remote\"",
"build:main": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.main.prod.ts",
"build:remote": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.remote.prod.ts",
"build:renderer": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.renderer.prod.ts",
"build:web": "cross-env NODE_ENV=production TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.web.prod.ts",
"build:docker": "docker build -t jeffvli/feishin .",
"rebuild": "electron-rebuild --parallel --types prod,dev,optional --module-dir release/app",
"lint": "concurrently \"npm run lint:code\" \"npm run lint:styles\"",
"lint:code": "cross-env NODE_ENV=development eslint . --ext .js,.jsx,.ts,.tsx --fix",
"lint:styles": "npx stylelint **/*.tsx --fix",
"package": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never",
"package:pr": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --win --mac --linux",
"package:pr:macos": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --mac",
"package:pr:windows": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --win",
"package:pr:linux": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --linux",
"package:dev": "node --import tsx ./.erb/scripts/clean.js dist && npm run build && electron-builder build --publish never --dir",
"postinstall": "node --import tsx .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",
"start": "node --import tsx ./.erb/scripts/check-port-in-use.js && npm run start:renderer",
"start:main": "cross-env NODE_ENV=development NODE_OPTIONS=\"--import tsx\" electron -r ts-node/register/transpile-only ./src/main/main.ts",
"start:preload": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.preload.dev.ts",
"start:remote": "cross-env NODE_ENV=developemnt TS_NODE_TRANSPILE_ONLY=true webpack --config ./.erb/configs/webpack.config.remote.dev.ts",
"start:renderer": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./.erb/configs/webpack.config.renderer.dev.ts",
"start:web": "cross-env NODE_ENV=development TS_NODE_TRANSPILE_ONLY=true webpack serve --config ./.erb/configs/webpack.config.renderer.web.ts",
"test": "jest",
"prepare": "husky install",
"i18next": "i18next -c src/i18n/i18next-parser.config.js",
"prod:buildserver": "pwsh -c \"./scripts/server-build.ps1\"",
"prod:publishserver": "pwsh -c \"./scripts/server-publish.ps1\""
},
"lint-staged": {
"*.{js,jsx,ts,tsx}": [
"cross-env NODE_ENV=development eslint --cache"
],
"*.json,.{eslintrc,prettierrc}": [
"prettier --ignore-path .eslintignore --parser json --write"
],
"*.{css,scss}": [
"prettier --ignore-path .eslintignore --single-quote --write"
],
"*.{html,md,yml}": [
"prettier --ignore-path .eslintignore --single-quote --write"
]
},
"build": {
"productName": "Feishin",
"appId": "org.jeffvli.feishin",
"artifactName": "${productName}-${version}-${os}-${arch}.${ext}",
"asar": true,
"asarUnpack": "**\\*.{node,dll}",
"files": [
"dist",
"node_modules",
"package.json"
],
"afterSign": ".erb/scripts/notarize.js",
"electronVersion": "36.1.0",
"mac": {
"target": {
"target": "default",
"arch": [
"arm64",
"x64"
]
},
"icon": "assets/icons/icon.icns",
"type": "distribution",
"hardenedRuntime": true,
"entitlements": "assets/entitlements.mac.plist",
"entitlementsInherit": "assets/entitlements.mac.plist",
"gatekeeperAssess": false
},
"dmg": {
"contents": [
{
"x": 130,
"y": 220
},
{
"x": 410,
"y": 220,
"type": "link",
"path": "/Applications"
}
]
},
"win": {
"target": [
"nsis",
"zip"
],
"icon": "assets/icons/icon.ico"
},
"deb": {
"depends": [
"libgssapi_krb5.so.2",
"libavahi-common.so.3",
"libavahi-client.so.3",
"libkrb5.so.3",
"libkrb5support.so.0",
"libkeyutils.so.1",
"libcups.so.2"
]
},
"rpm": {
"depends": [
"libgssapi_krb5.so.2",
"libavahi-common.so.3",
"libavahi-client.so.3",
"libkrb5.so.3",
"libkrb5support.so.0",
"libkeyutils.so.1",
"libcups.so.2"
]
},
"freebsd": {
"depends": [
"libgssapi_krb5.so.2",
"libavahi-common.so.3",
"libavahi-client.so.3",
"libkrb5.so.3",
"libkrb5support.so.0",
"libkeyutils.so.1",
"libcups.so.2"
]
},
"linux": {
"target": [
"AppImage",
"tar.xz"
],
"icon": "assets/icons/icon.png",
"category": "AudioVideo;Audio;Player"
},
"directories": {
"app": "release/app",
"buildResources": "assets",
"output": "release/build"
},
"extraResources": [
"./assets/**"
],
"publish": {
"provider": "github",
"owner": "jeffvli",
"repo": "feishin"
}
},
"repository": {
"type": "git",
"url": "git+https://github.com/jeffvli/feishin.git"
},
"author": {
"name": "jeffvli",
"url": "https://github.com/jeffvli/"
},
"contributors": [],
"license": "GPL-3.0",
"bugs": {
"url": "https://github.com/jeffvli/feishin/issues"
},
"keywords": [ "keywords": [
"subsonic", "subsonic",
"navidrome", "navidrome",
"airsonic",
"jellyfin", "jellyfin",
"react", "react",
"electron" "electron"
], ],
"homepage": "https://github.com/jeffvli/feishin", "homepage": "https://github.com/jeffvli/feishin",
"jest": { "bugs": {
"testURL": "http://localhost/", "url": "https://github.com/jeffvli/feishin/issues"
"testEnvironment": "jsdom",
"transform": {
"\\.(ts|tsx|js|jsx)$": "ts-jest"
},
"moduleNameMapper": {
"\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$": "<rootDir>/.erb/mocks/fileMock.js",
"\\.(css|less|sass|scss)$": "identity-obj-proxy"
},
"moduleFileExtensions": [
"js",
"jsx",
"ts",
"tsx",
"json"
],
"moduleDirectories": [
"node_modules",
"release/app/node_modules"
],
"testPathIgnorePatterns": [
"release/app/dist"
],
"setupFiles": [
"./.erb/scripts/check-build-exists.ts"
]
}, },
"devDependencies": { "license": "GPL-3.0",
"@electron/rebuild": "^3.6.0", "author": {
"@pmmmwh/react-refresh-webpack-plugin": "0.5.5", "name": "jeffvli",
"@stylelint/postcss-css-in-js": "^0.38.0", "url": "https://github.com/jeffvli/"
"@teamsupercell/typings-for-css-modules-loader": "^2.5.1", },
"@testing-library/jest-dom": "^5.16.4", "main": "./out/main/index.js",
"@testing-library/react": "^13.0.0", "scripts": {
"@types/dompurify": "^3.0.5", "build": "pnpm run typecheck && pnpm run build:electron && pnpm run build:remote",
"@types/electron-localshortcut": "^3.1.0", "build:electron": "electron-vite build",
"@types/jest": "^27.4.1", "build:remote": "vite build --config remote.vite.config.ts",
"@types/lodash": "^4.14.188", "build:web": "vite build --config web.vite.config.ts",
"@types/md5": "^2.3.2", "dev": "electron-vite dev",
"@types/node": "^17.0.23", "dev:watch": "electron-vite dev --watch",
"@types/react": "^18.0.25", "i18next": "i18next -c src/i18n/i18next-parser.config.js",
"@types/react-dom": "^18.0.8", "postinstall": "electron-builder install-app-deps",
"@types/react-test-renderer": "^17.0.1", "lint": "eslint --cache .",
"@types/react-virtualized-auto-sizer": "^1.0.1", "lint:fix": "eslint --cache --fix .",
"@types/react-window": "^1.8.5", "package": "pnpm run build && electron-builder",
"@types/react-window-infinite-loader": "^1.0.6", "package:dev": "pnpm run build && electron-builder --dir",
"@types/styled-components": "^5.1.26", "package:linux": "pnpm run build && electron-builder --linux",
"@types/terser-webpack-plugin": "^5.0.4", "package:linux-arm64:pr": "pnpm run build && electron-builder --linux --arm64 --publish never",
"@types/webpack-bundle-analyzer": "^4.4.1", "package:linux:pr": "pnpm run build && electron-builder --linux --publish never",
"@types/webpack-env": "^1.16.3", "package:mac": "pnpm run build && electron-builder --mac",
"@typescript-eslint/eslint-plugin": "^5.47.0", "package:mac:pr": "pnpm run build && electron-builder --mac --publish never",
"@typescript-eslint/parser": "^5.47.0", "package:win": "pnpm run build && electron-builder --win",
"browserslist-config-erb": "^0.0.3", "package:win:pr": "pnpm run build && electron-builder --win --publish never",
"chalk": "^4.1.2", "publish:linux": "electron-builder --publish always --linux",
"concurrently": "^7.1.0", "publish:linux-arm64": "electron-builder --publish always --linux --arm64",
"core-js": "^3.21.1", "publish:mac": "electron-builder --publish always --mac",
"cross-env": "^7.0.3", "publish:win": "electron-builder --publish always --win",
"css-loader": "^6.7.1", "start": "electron-vite preview",
"css-minimizer-webpack-plugin": "^3.4.1", "typecheck": "pnpm run typecheck:node && pnpm run typecheck:web",
"detect-port": "^1.3.0", "typecheck:node": "tsc --noEmit -p tsconfig.node.json --composite false",
"electron": "^36.1.0", "typecheck:web": "tsc --noEmit -p tsconfig.web.json --composite false"
"electron-builder": "^24.13.3",
"electron-devtools-installer": "^3.2.0",
"electron-notarize": "^1.2.1",
"electronmon": "^2.0.2",
"eslint": "^8.30.0",
"eslint-config-airbnb-base": "^15.0.0",
"eslint-config-erb": "^4.0.3",
"eslint-import-resolver-typescript": "^2.7.1",
"eslint-import-resolver-webpack": "^0.13.2",
"eslint-plugin-compat": "^4.2.0",
"eslint-plugin-import": "^2.26.0",
"eslint-plugin-jest": "^26.1.3",
"eslint-plugin-jsx-a11y": "^6.5.1",
"eslint-plugin-promise": "^6.0.0",
"eslint-plugin-react": "^7.29.4",
"eslint-plugin-react-hooks": "^4.4.0",
"eslint-plugin-sort-keys-fix": "^1.1.2",
"eslint-plugin-typescript-sort-keys": "^2.1.0",
"file-loader": "^6.2.0",
"html-webpack-plugin": "^5.5.0",
"husky": "^7.0.4",
"i18next-parser": "^9.0.2",
"identity-obj-proxy": "^3.0.0",
"jest": "^27.5.1",
"lint-staged": "^12.3.7",
"mini-css-extract-plugin": "^2.6.0",
"postcss-scss": "^4.0.4",
"postcss-styled-syntax": "^0.5.0",
"postcss-syntax": "^0.36.2",
"prettier": "^3.3.3",
"react-refresh": "^0.12.0",
"react-refresh-typescript": "^2.0.4",
"react-test-renderer": "^18.0.0",
"rimraf": "^3.0.2",
"sass": "^1.49.11",
"sass-loader": "^12.6.0",
"style-loader": "^3.3.1",
"stylelint": "^15.10.3",
"stylelint-config-css-modules": "^4.3.0",
"stylelint-config-recess-order": "^4.3.0",
"stylelint-config-standard": "^34.0.0",
"stylelint-config-standard-scss": "^4.0.0",
"stylelint-config-styled-components": "^0.1.1",
"terser-webpack-plugin": "^5.3.1",
"ts-jest": "^27.1.4",
"ts-loader": "^9.2.8",
"ts-node": "^10.9.2",
"tsconfig-paths-webpack-plugin": "^4.0.0",
"tsx": "^4.16.2",
"typescript": "^5.2.2",
"typescript-plugin-styled-components": "^3.0.0",
"url-loader": "^4.1.1",
"webpack": "^5.94.0",
"webpack-bundle-analyzer": "^4.5.0",
"webpack-cli": "^4.9.2",
"webpack-dev-server": "^4.8.0",
"webpack-merge": "^5.8.0"
}, },
"dependencies": { "dependencies": {
"@ag-grid-community/client-side-row-model": "^28.2.1", "@ag-grid-community/client-side-row-model": "^28.2.1",
@ -299,14 +54,16 @@
"@ag-grid-community/infinite-row-model": "^28.2.1", "@ag-grid-community/infinite-row-model": "^28.2.1",
"@ag-grid-community/react": "^28.2.1", "@ag-grid-community/react": "^28.2.1",
"@ag-grid-community/styles": "^28.2.1", "@ag-grid-community/styles": "^28.2.1",
"@electron-toolkit/preload": "^3.0.1",
"@electron-toolkit/utils": "^4.0.0",
"@emotion/react": "^11.10.4", "@emotion/react": "^11.10.4",
"@mantine/core": "^6.0.17", "@mantine/core": "^6.0.22",
"@mantine/dates": "^6.0.17", "@mantine/dates": "^6.0.22",
"@mantine/form": "^6.0.17", "@mantine/form": "^6.0.22",
"@mantine/hooks": "^6.0.17", "@mantine/hooks": "^6.0.22",
"@mantine/modals": "^6.0.17", "@mantine/modals": "^6.0.22",
"@mantine/notifications": "^6.0.17", "@mantine/notifications": "^6.0.22",
"@mantine/utils": "^6.0.17", "@mantine/utils": "^6.0.22",
"@tanstack/react-query": "^4.32.1", "@tanstack/react-query": "^4.32.1",
"@tanstack/react-query-devtools": "^4.32.1", "@tanstack/react-query-devtools": "^4.32.1",
"@tanstack/react-query-persist-client": "^4.32.1", "@tanstack/react-query-persist-client": "^4.32.1",
@ -315,6 +72,7 @@
"audiomotion-analyzer": "^4.5.0", "audiomotion-analyzer": "^4.5.0",
"auto-text-size": "^0.2.3", "auto-text-size": "^0.2.3",
"axios": "^1.6.0", "axios": "^1.6.0",
"cheerio": "^1.0.0",
"clsx": "^2.0.0", "clsx": "^2.0.0",
"cmdk": "^0.2.0", "cmdk": "^0.2.0",
"dayjs": "^1.11.6", "dayjs": "^1.11.6",
@ -323,12 +81,11 @@
"electron-localshortcut": "^3.2.1", "electron-localshortcut": "^3.2.1",
"electron-log": "^5.1.1", "electron-log": "^5.1.1",
"electron-store": "^8.1.0", "electron-store": "^8.1.0",
"electron-updater": "^6.3.1", "electron-updater": "^6.3.9",
"fast-average-color": "^9.3.0", "fast-average-color": "^9.3.0",
"format-duration": "^2.0.0", "format-duration": "^2.0.0",
"framer-motion": "^11.0.0", "framer-motion": "^11.0.0",
"fuse.js": "^6.6.2", "fuse.js": "^6.6.2",
"history": "^5.3.0",
"i18next": "^21.10.0", "i18next": "^21.10.0",
"idb-keyval": "^6.2.1", "idb-keyval": "^6.2.1",
"immer": "^9.0.21", "immer": "^9.0.21",
@ -336,13 +93,12 @@
"lodash": "^4.17.21", "lodash": "^4.17.21",
"md5": "^2.3.0", "md5": "^2.3.0",
"memoize-one": "^6.0.0", "memoize-one": "^6.0.0",
"mpris-service": "^2.1.2",
"nanoid": "^3.3.3", "nanoid": "^3.3.3",
"net": "^1.0.2",
"node-mpv": "github:jeffvli/Node-MPV#32b4d64395289ad710c41d481d2707a7acfc228f", "node-mpv": "github:jeffvli/Node-MPV#32b4d64395289ad710c41d481d2707a7acfc228f",
"overlayscrollbars": "^2.2.1", "overlayscrollbars": "^2.11.1",
"overlayscrollbars-react": "^0.5.1", "overlayscrollbars-react": "^0.5.6",
"react": "^18.2.0", "qs": "^6.14.0",
"react-dom": "^18.2.0",
"react-error-boundary": "^3.1.4", "react-error-boundary": "^3.1.4",
"react-i18next": "^11.18.6", "react-i18next": "^11.18.6",
"react-icons": "^4.10.1", "react-icons": "^4.10.1",
@ -356,33 +112,63 @@
"semver": "^7.5.4", "semver": "^7.5.4",
"styled-components": "^6.0.8", "styled-components": "^6.0.8",
"swiper": "^9.3.1", "swiper": "^9.3.1",
"ws": "^8.18.2",
"zod": "^3.22.3", "zod": "^3.22.3",
"zustand": "^4.3.9" "zustand": "^4.3.9"
}, },
"resolutions": { "devDependencies": {
"styled-components": "^6", "@electron-toolkit/eslint-config-prettier": "^3.0.0",
"entities": "2.2.0" "@electron-toolkit/eslint-config-ts": "^3.0.0",
"@electron-toolkit/tsconfig": "^1.0.1",
"@types/electron-localshortcut": "^3.1.0",
"@types/lodash": "^4.14.188",
"@types/md5": "^2.3.2",
"@types/node": "^22.14.1",
"@types/react": "^18.3.1",
"@types/react-dom": "^18.3.1",
"@types/react-window": "^1.8.5",
"@types/react-window-infinite-loader": "^1.0.6",
"@types/source-map-support": "^0.5.10",
"@types/styled-components": "^5.1.26",
"@types/ws": "^8.18.1",
"@vitejs/plugin-react": "^4.3.4",
"concurrently": "^7.1.0",
"cross-env": "^7.0.3",
"electron": "^35.1.5",
"electron-builder": "^26.0.12",
"electron-devtools-installer": "^3.2.0",
"electron-vite": "^3.1.0",
"eslint": "^9.24.0",
"eslint-plugin-perfectionist": "^4.13.0",
"eslint-plugin-prettier": "^5.4.0",
"eslint-plugin-react": "^7.37.5",
"eslint-plugin-react-hooks": "^5.2.0",
"eslint-plugin-react-refresh": "^0.4.19",
"i18next-parser": "^9.0.2",
"postcss-styled-syntax": "^0.5.0",
"prettier": "^3.5.3",
"prettier-plugin-packagejson": "^2.5.14",
"react": "^18.3.1",
"react-dom": "^18.3.1",
"sass-embedded": "^1.89.0",
"stylelint": "^15.10.3",
"stylelint-config-css-modules": "^4.3.0",
"stylelint-config-recess-order": "^4.3.0",
"stylelint-config-standard": "^34.0.0",
"stylelint-config-standard-scss": "^4.0.0",
"stylelint-config-styled-components": "^0.1.1",
"typescript": "^5.8.3",
"typescript-plugin-styled-components": "^3.0.0",
"vite": "^6.3.5",
"vite-plugin-conditional-import": "^0.1.7",
"vite-plugin-dynamic-import": "^1.6.0",
"vite-plugin-ejs": "^1.7.0"
}, },
"overrides": { "pnpm": {
"entities": "2.2.0" "onlyBuiltDependencies": [
}, "electron",
"devEngines": { "esbuild"
"runtime": {
"name": "node",
"version": ">=18.x",
"onFail": "error"
},
"packageManager": {
"name": "npm",
"version": ">=7.x",
"onFail": "error"
}
},
"browserslist": [],
"electronmon": {
"patterns": [
"!server",
"!src/renderer"
] ]
} },
"productName": "feishin"
} }

10233
pnpm-lock.yaml generated Normal file
View file

File diff suppressed because it is too large Load diff

2352
release/app/package-lock.json generated
View file

File diff suppressed because it is too large Load diff

30
release/app/package.json
View file

@ -1,30 +0,0 @@
{
"name": "feishin",
"version": "0.13.0",
"description": "",
"main": "./dist/main/main.js",
"author": {
"name": "jeffvli",
"url": "https://github.com/jeffvli/"
},
"scripts": {
"electron-rebuild": "node -r ts-node/register ../../.erb/scripts/electron-rebuild.js",
"link-modules": "node -r ts-node/register ../../.erb/scripts/link-modules.ts",
"postinstall": "npm run electron-rebuild && npm run link-modules"
},
"dependencies": {
"cheerio": "^1.0.0-rc.12",
"mpris-service": "^2.1.2",
"ws": "^8.18.0"
},
"devDependencies": {
"electron": "36.1.0"
},
"resolutions": {
"xml2js": "0.5.0"
},
"overrides": {
"xml2js": "0.5.0"
},
"license": "GPL-3.0"
}

44
remote.vite.config.ts Normal file
View file

@ -0,0 +1,44 @@
import react from '@vitejs/plugin-react';
import path from 'path';
import { defineConfig, normalizePath } from 'vite';
import { ViteEjsPlugin } from 'vite-plugin-ejs';
import { version } from './package.json';
export default defineConfig({
build: {
emptyOutDir: true,
outDir: path.resolve(__dirname, './out/remote'),
rollupOptions: {
input: {
favicon: normalizePath(path.resolve(__dirname, './assets/icons/favicon.ico')),
index: normalizePath(path.resolve(__dirname, './src/remote/index.html')),
manifest: normalizePath(path.resolve(__dirname, './src/remote/manifest.json')),
remote: normalizePath(path.resolve(__dirname, './src/remote/index.tsx')),
worker: normalizePath(path.resolve(__dirname, './src/remote/service-worker.ts')),
},
output: {
assetFileNames: '[name].[ext]',
chunkFileNames: '[name].js',
entryFileNames: '[name].js',
},
},
},
plugins: [
react(),
ViteEjsPlugin({
prod: process.env.NODE_ENV === 'production',
root: normalizePath(path.resolve(__dirname, './src/remote')),
version,
}),
],
resolve: {
alias: {
'/@/i18n': path.resolve(__dirname, './src/i18n'),
'/@/remote': path.resolve(__dirname, './src/remote'),
'/@/renderer': path.resolve(__dirname, './src/renderer'),
'/@/shared': path.resolve(__dirname, './src/shared'),
},
},
root: path.resolve(__dirname, './src/remote'),
});

BIN
resources/icon.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 48 KiB

9
src/__tests__/App.test.tsx
View file

@ -1,9 +0,0 @@
import '@testing-library/jest-dom';
import { render } from '@testing-library/react';
import { App } from '../renderer/app';
describe('App', () => {
it('should render', () => {
expect(render(<App />)).toBeTruthy();
});
});

65
src/i18n/i18n.ts
View file

@ -1,52 +1,53 @@
import { PostProcessorModule, TOptions, StringMap } from 'i18next'; import { PostProcessorModule, StringMap, TOptions } from 'i18next';
import i18n from 'i18next'; import i18n from 'i18next';
import { initReactI18next } from 'react-i18next'; import { initReactI18next } from 'react-i18next';
import cs from './locales/cs.json';
import de from './locales/de.json';
import en from './locales/en.json'; import en from './locales/en.json';
import es from './locales/es.json'; import es from './locales/es.json';
import fa from './locales/fa.json';
import fi from './locales/fi.json';
import fr from './locales/fr.json'; import fr from './locales/fr.json';
import ja from './locales/ja.json'; import hu from './locales/hu.json';
import pl from './locales/pl.json'; import id from './locales/id.json';
import zhHans from './locales/zh-Hans.json';
import de from './locales/de.json';
import it from './locales/it.json'; import it from './locales/it.json';
import ru from './locales/ru.json'; import ja from './locales/ja.json';
import ptBr from './locales/pt-BR.json'; import ko from './locales/ko.json';
import sr from './locales/sr.json';
import sv from './locales/sv.json';
import cs from './locales/cs.json';
import nbNO from './locales/nb-NO.json'; import nbNO from './locales/nb-NO.json';
import nl from './locales/nl.json'; import nl from './locales/nl.json';
import zhHant from './locales/zh-Hant.json'; import pl from './locales/pl.json';
import fa from './locales/fa.json'; import ptBr from './locales/pt-BR.json';
import ko from './locales/ko.json'; import ru from './locales/ru.json';
import sr from './locales/sr.json';
import sv from './locales/sv.json';
import ta from './locales/ta.json'; import ta from './locales/ta.json';
import id from './locales/id.json'; import zhHans from './locales/zh-Hans.json';
import fi from './locales/fi.json'; import zhHant from './locales/zh-Hant.json';
import hu from './locales/hu.json';
const resources = { const resources = {
cs: { translation: cs },
de: { translation: de },
en: { translation: en }, en: { translation: en },
es: { translation: es }, es: { translation: es },
de: { translation: de },
it: { translation: it },
ru: { translation: ru },
'pt-BR': { translation: ptBr },
fa: { translation: fa }, fa: { translation: fa },
fi: { translation: fi },
fr: { translation: fr }, fr: { translation: fr },
hu: { translation: hu },
id: { translation: id },
it: { translation: it },
ja: { translation: ja }, ja: { translation: ja },
ko: { translation: ko }, ko: { translation: ko },
'nb-NO': { translation: nbNO },
nl: { translation: nl },
pl: { translation: pl }, pl: { translation: pl },
'zh-Hans': { translation: zhHans }, 'pt-BR': { translation: ptBr },
'zh-Hant': { translation: zhHant }, ru: { translation: ru },
sr: { translation: sr }, sr: { translation: sr },
sv: { translation: sv }, sv: { translation: sv },
cs: { translation: cs },
nl: { translation: nl },
'nb-NO': { translation: nbNO },
ta: { translation: ta }, ta: { translation: ta },
id: { translation: id }, 'zh-Hans': { translation: zhHans },
fi: { translation: fi }, 'zh-Hant': { translation: zhHant },
hu: { translation: hu },
}; };
export const languages = [ export const languages = [
@ -141,35 +142,34 @@ export const languages = [
]; ];
const lowerCasePostProcessor: PostProcessorModule = { const lowerCasePostProcessor: PostProcessorModule = {
type: 'postProcessor',
name: 'lowerCase', name: 'lowerCase',
process: (value: string) => { process: (value: string) => {
return value.toLocaleLowerCase(); return value.toLocaleLowerCase();
}, },
type: 'postProcessor',
}; };
const upperCasePostProcessor: PostProcessorModule = { const upperCasePostProcessor: PostProcessorModule = {
type: 'postProcessor',
name: 'upperCase', name: 'upperCase',
process: (value: string) => { process: (value: string) => {
return value.toLocaleUpperCase(); return value.toLocaleUpperCase();
}, },
type: 'postProcessor',
}; };
const titleCasePostProcessor: PostProcessorModule = { const titleCasePostProcessor: PostProcessorModule = {
type: 'postProcessor',
name: 'titleCase', name: 'titleCase',
process: (value: string) => { process: (value: string) => {
return value.replace(/\S\S*/g, (txt) => { return value.replace(/\S\S*/g, (txt) => {
return txt.charAt(0).toLocaleUpperCase() + txt.slice(1).toLowerCase(); return txt.charAt(0).toLocaleUpperCase() + txt.slice(1).toLowerCase();
}); });
}, },
type: 'postProcessor',
}; };
const ignoreSentenceCaseLanguages = ['de']; const ignoreSentenceCaseLanguages = ['de'];
const sentenceCasePostProcessor: PostProcessorModule = { const sentenceCasePostProcessor: PostProcessorModule = {
type: 'postProcessor',
name: 'sentenceCase', name: 'sentenceCase',
process: (value: string, _key: string, _options: TOptions<StringMap>, translator: any) => { process: (value: string, _key: string, _options: TOptions<StringMap>, translator: any) => {
const sentences = value.split('. '); const sentences = value.split('. ');
@ -185,6 +185,7 @@ const sentenceCasePostProcessor: PostProcessorModule = {
}) })
.join('. '); .join('. ');
}, },
type: 'postProcessor',
}; };
i18n.use(lowerCasePostProcessor) i18n.use(lowerCasePostProcessor)
.use(upperCasePostProcessor) .use(upperCasePostProcessor)

2
src/i18n/i18next-parser.config.js
View file

@ -5,7 +5,7 @@ module.exports = {
createOldCatalogs: true, createOldCatalogs: true,
customValueTemplate: null, customValueTemplate: null,
defaultNamespace: 'translation', defaultNamespace: 'translation',
defaultValue: function (locale, namespace, key, value) { defaultValue: function (locale, namespace, key) {
return key; return key;
}, },
failOnUpdate: false, failOnUpdate: false,

163
src/main/features/core/lyrics/genius.ts
View file

@ -1,12 +1,13 @@
import axios, { AxiosResponse } from 'axios'; import axios, { AxiosResponse } from 'axios';
import { load } from 'cheerio'; import { load } from 'cheerio';
import { orderSearchResults } from './shared';
import { import {
LyricSource,
InternetProviderLyricResponse, InternetProviderLyricResponse,
InternetProviderLyricSearchResponse, InternetProviderLyricSearchResponse,
LyricSearchQuery, LyricSearchQuery,
} from '../../../../renderer/api/types'; LyricSource,
} from '.';
import { orderSearchResults } from './shared';
const SEARCH_URL = 'https://genius.com/api/search/song'; const SEARCH_URL = 'https://genius.com/api/search/song';
@ -17,20 +18,6 @@ export interface GeniusResponse {
response: Response; response: Response;
} }
export interface Meta {
status: number;
}
export interface Response {
next_page: number;
sections: Section[];
}
export interface Section {
hits: Hit[];
type: string;
}
export interface Hit { export interface Hit {
highlights: any[]; highlights: any[];
index: string; index: string;
@ -38,6 +25,35 @@ export interface Hit {
type: string; type: string;
} }
export interface Meta {
status: number;
}
export interface PrimaryArtist {
_type: string;
api_path: string;
header_image_url: string;
id: number;
image_url: string;
index_character: string;
is_meme_verified: boolean;
is_verified: boolean;
name: string;
slug: string;
url: string;
}
export interface ReleaseDateComponents {
day: number;
month: number;
year: number;
}
export interface Response {
next_page: number;
sections: Section[];
}
export interface Result { export interface Result {
_type: string; _type: string;
annotation_count: number; annotation_count: number;
@ -69,24 +85,9 @@ export interface Result {
url: string; url: string;
} }
export interface PrimaryArtist { export interface Section {
_type: string; hits: Hit[];
api_path: string; type: string;
header_image_url: string;
id: number;
image_url: string;
index_character: string;
is_meme_verified: boolean;
is_verified: boolean;
name: string;
slug: string;
url: string;
}
export interface ReleaseDateComponents {
day: number;
month: number;
year: number;
} }
export interface Stats { export interface Stats {
@ -94,6 +95,27 @@ export interface Stats {
unreviewed_annotations: number; unreviewed_annotations: number;
} }
export async function getLyricsBySongId(url: string): Promise<null | string> {
let result: AxiosResponse<string, any>;
try {
result = await axios.get<string>(url, { responseType: 'text' });
} catch (e) {
console.error('Genius lyrics request got an error!', e);
return null;
}
const $ = load(result.data.split('<br/>').join('\n'));
const lyricsDiv = $('div.lyrics');
if (lyricsDiv.length > 0) return lyricsDiv.text().trim();
const lyricSections = $('div[class^=Lyrics__Container]')
.map((_, e) => $(e).text())
.toArray()
.join('\n');
return lyricSections;
}
export async function getSearchResults( export async function getSearchResults(
params: LyricSearchQuery, params: LyricSearchQuery,
): Promise<InternetProviderLyricSearchResponse[] | null> { ): Promise<InternetProviderLyricSearchResponse[] | null> {
@ -133,9 +155,33 @@ export async function getSearchResults(
return orderSearchResults({ params, results: songResults }); return orderSearchResults({ params, results: songResults });
} }
export async function query(
params: LyricSearchQuery,
): Promise<InternetProviderLyricResponse | null> {
const response = await getSongId(params);
if (!response) {
console.error('Could not find the song on Genius!');
return null;
}
const lyrics = await getLyricsBySongId(response.id);
if (!lyrics) {
console.error('Could not get lyrics on Genius!');
return null;
}
return {
artist: response.artist,
id: response.id,
lyrics,
name: response.name,
source: LyricSource.GENIUS,
};
}
async function getSongId( async function getSongId(
params: LyricSearchQuery, params: LyricSearchQuery,
): Promise<Omit<InternetProviderLyricResponse, 'lyrics'> | null> { ): Promise<null | Omit<InternetProviderLyricResponse, 'lyrics'>> {
let result: AxiosResponse<GeniusResponse>; let result: AxiosResponse<GeniusResponse>;
try { try {
result = await axios.get(SEARCH_URL, { result = await axios.get(SEARCH_URL, {
@ -162,48 +208,3 @@ async function getSongId(
source: LyricSource.GENIUS, source: LyricSource.GENIUS,
}; };
} }
export async function getLyricsBySongId(url: string): Promise<string | null> {
let result: AxiosResponse<string, any>;
try {
result = await axios.get<string>(url, { responseType: 'text' });
} catch (e) {
console.error('Genius lyrics request got an error!', e);
return null;
}
const $ = load(result.data.split('<br/>').join('\n'));
const lyricsDiv = $('div.lyrics');
if (lyricsDiv.length > 0) return lyricsDiv.text().trim();
const lyricSections = $('div[class^=Lyrics__Container]')
.map((_, e) => $(e).text())
.toArray()
.join('\n');
return lyricSections;
}
export async function query(
params: LyricSearchQuery,
): Promise<InternetProviderLyricResponse | null> {
const response = await getSongId(params);
if (!response) {
console.error('Could not find the song on Genius!');
return null;
}
const lyrics = await getLyricsBySongId(response.id);
if (!lyrics) {
console.error('Could not get lyrics on Genius!');
return null;
}
return {
artist: response.artist,
id: response.id,
lyrics,
name: response.name,
source: LyricSource.GENIUS,
};
}

92
src/main/features/core/lyrics/index.ts
View file

@ -1,36 +1,78 @@
import { ipcMain } from 'electron'; import { ipcMain } from 'electron';
import { store } from '../settings';
import { import {
getLyricsBySongId as getGenius,
query as queryGenius, query as queryGenius,
getSearchResults as searchGenius, getSearchResults as searchGenius,
getLyricsBySongId as getGenius,
} from './genius'; } from './genius';
import { import {
getLyricsBySongId as getLrcLib,
query as queryLrclib, query as queryLrclib,
getSearchResults as searchLrcLib, getSearchResults as searchLrcLib,
getLyricsBySongId as getLrcLib,
} from './lrclib'; } from './lrclib';
import { import {
getLyricsBySongId as getNetease,
query as queryNetease, query as queryNetease,
getSearchResults as searchNetease, getSearchResults as searchNetease,
getLyricsBySongId as getNetease,
} from './netease'; } from './netease';
import {
InternetProviderLyricResponse,
InternetProviderLyricSearchResponse,
LyricSearchQuery,
QueueSong,
LyricGetQuery,
LyricSource,
} from '../../../../renderer/api/types';
import { store } from '../settings/index';
type SongFetcher = (params: LyricSearchQuery) => Promise<InternetProviderLyricResponse | null>; import { Song } from '/@/shared/types/domain-types';
export enum LyricSource {
GENIUS = 'Genius',
LRCLIB = 'lrclib.net',
NETEASE = 'NetEase',
}
export type FullLyricsMetadata = Omit<InternetProviderLyricResponse, 'id' | 'lyrics' | 'source'> & {
lyrics: LyricsResponse;
remote: boolean;
source: string;
};
export type InternetProviderLyricResponse = {
artist: string;
id: string;
lyrics: string;
name: string;
source: LyricSource;
};
export type InternetProviderLyricSearchResponse = {
artist: string;
id: string;
name: string;
score?: number;
source: LyricSource;
};
export type LyricGetQuery = {
remoteSongId: string;
remoteSource: LyricSource;
song: Song;
};
export type LyricOverride = Omit<InternetProviderLyricResponse, 'lyrics'>;
export type LyricSearchQuery = {
album?: string;
artist?: string;
duration?: number;
name?: string;
};
export type LyricsResponse = string | SynchronizedLyricsArray;
export type SynchronizedLyricsArray = Array<[number, string]>;
type CachedLyrics = Record<LyricSource, InternetProviderLyricResponse>;
type GetFetcher = (id: string) => Promise<null | string>;
type SearchFetcher = ( type SearchFetcher = (
params: LyricSearchQuery, params: LyricSearchQuery,
) => Promise<InternetProviderLyricSearchResponse[] | null>; ) => Promise<InternetProviderLyricSearchResponse[] | null>;
type GetFetcher = (id: string) => Promise<string | null>;
type CachedLyrics = Record<LyricSource, InternetProviderLyricResponse>; type SongFetcher = (params: LyricSearchQuery) => Promise<InternetProviderLyricResponse | null>;
const FETCHERS: Record<LyricSource, SongFetcher> = { const FETCHERS: Record<LyricSource, SongFetcher> = {
[LyricSource.GENIUS]: queryGenius, [LyricSource.GENIUS]: queryGenius,
@ -54,10 +96,10 @@ const MAX_CACHED_ITEMS = 10;
const lyricCache = new Map<string, CachedLyrics>(); const lyricCache = new Map<string, CachedLyrics>();
const getRemoteLyrics = async (song: QueueSong) => { const getRemoteLyrics = async (song: Song) => {
const sources = store.get('lyrics', []) as LyricSource[]; const sources = store.get('lyrics', []) as LyricSource[];
const cached = lyricCache.get(song.id); const cached = lyricCache.get(song.id.toString());
if (cached) { if (cached) {
for (const source of sources) { for (const source of sources) {
@ -66,16 +108,16 @@ const getRemoteLyrics = async (song: QueueSong) => {
} }
} }
let lyricsFromSource = null; let lyricsFromSource: InternetProviderLyricResponse | null = null;
for (const source of sources) { for (const source of sources) {
const params = { const params = {
album: song.album || song.name, album: song.album || song.name,
artist: song.artistName, artist: song.artists[0].name,
duration: song.duration / 1000.0, duration: song.duration / 1000.0,
name: song.name, name: song.name,
}; };
const response = await FETCHERS[source](params); const response = await FETCHERS[source](params as unknown as LyricSearchQuery);
if (response) { if (response) {
const newResult = cached const newResult = cached
@ -87,10 +129,12 @@ const getRemoteLyrics = async (song: QueueSong) => {
if (lyricCache.size === MAX_CACHED_ITEMS && cached === undefined) { if (lyricCache.size === MAX_CACHED_ITEMS && cached === undefined) {
const toRemove = lyricCache.keys().next().value; const toRemove = lyricCache.keys().next().value;
lyricCache.delete(toRemove); if (toRemove) {
lyricCache.delete(toRemove);
}
} }
lyricCache.set(song.id, newResult); lyricCache.set(song.id.toString(), newResult);
lyricsFromSource = response; lyricsFromSource = response;
break; break;
@ -122,7 +166,7 @@ const searchRemoteLyrics = async (params: LyricSearchQuery) => {
return results; return results;
}; };
const getRemoteLyricsById = async (params: LyricGetQuery): Promise<string | null> => { const getRemoteLyricsById = async (params: LyricGetQuery): Promise<null | string> => {
const { remoteSongId, remoteSource } = params; const { remoteSongId, remoteSource } = params;
const response = await GET_FETCHERS[remoteSource](remoteSongId); const response = await GET_FETCHERS[remoteSource](remoteSongId);
@ -133,7 +177,7 @@ const getRemoteLyricsById = async (params: LyricGetQuery): Promise<string | null
return response; return response;
}; };
ipcMain.handle('lyric-by-song', async (_event, song: QueueSong) => { ipcMain.handle('lyric-by-song', async (_event, song: any) => {
const lyric = await getRemoteLyrics(song); const lyric = await getRemoteLyrics(song);
return lyric; return lyric;
}); });

35
src/main/features/core/lyrics/lrclib.ts
View file

@ -1,12 +1,13 @@
// Credits to https://github.com/tranxuanthang/lrcget for API implementation // Credits to https://github.com/tranxuanthang/lrcget for API implementation
import axios, { AxiosResponse } from 'axios'; import axios, { AxiosResponse } from 'axios';
import { orderSearchResults } from './shared';
import { import {
InternetProviderLyricResponse, InternetProviderLyricResponse,
InternetProviderLyricSearchResponse, InternetProviderLyricSearchResponse,
LyricSearchQuery, LyricSearchQuery,
LyricSource, LyricSource,
} from '../../../../renderer/api/types'; } from '.';
import { orderSearchResults } from './shared';
const FETCH_URL = 'https://lrclib.net/api/get'; const FETCH_URL = 'https://lrclib.net/api/get';
const SEEARCH_URL = 'https://lrclib.net/api/search'; const SEEARCH_URL = 'https://lrclib.net/api/search';
@ -29,10 +30,23 @@ export interface LrcLibTrackResponse {
isrc: string; isrc: string;
lang: string; lang: string;
name: string; name: string;
plainLyrics: string | null; plainLyrics: null | string;
releaseDate: string; releaseDate: string;
spotifyId: string; spotifyId: string;
syncedLyrics: string | null; syncedLyrics: null | string;
}
export async function getLyricsBySongId(songId: string): Promise<null | string> {
let result: AxiosResponse<LrcLibTrackResponse, any>;
try {
result = await axios.get<LrcLibTrackResponse>(`${FETCH_URL}/${songId}`);
} catch (e) {
console.error('LrcLib lyrics request got an error!', e);
return null;
}
return result.data.syncedLyrics || result.data.plainLyrics || null;
} }
export async function getSearchResults( export async function getSearchResults(
@ -69,19 +83,6 @@ export async function getSearchResults(
return orderSearchResults({ params, results: songResults }); return orderSearchResults({ params, results: songResults });
} }
export async function getLyricsBySongId(songId: string): Promise<string | null> {
let result: AxiosResponse<LrcLibTrackResponse, any>;
try {
result = await axios.get<LrcLibTrackResponse>(`${FETCH_URL}/${songId}`);
} catch (e) {
console.error('LrcLib lyrics request got an error!', e);
return null;
}
return result.data.syncedLyrics || result.data.plainLyrics || null;
}
export async function query( export async function query(
params: LyricSearchQuery, params: LyricSearchQuery,
): Promise<InternetProviderLyricResponse | null> { ): Promise<InternetProviderLyricResponse | null> {

89
src/main/features/core/lyrics/netease.ts
View file

@ -1,22 +1,18 @@
import axios, { AxiosResponse } from 'axios'; import axios, { AxiosResponse } from 'axios';
import { LyricSource } from '../../../../renderer/api/types';
import { orderSearchResults } from './shared'; import {
import type {
InternetProviderLyricResponse, InternetProviderLyricResponse,
InternetProviderLyricSearchResponse, InternetProviderLyricSearchResponse,
LyricSearchQuery, LyricSearchQuery,
} from '/@/renderer/api/types'; LyricSource,
} from '.';
import { orderSearchResults } from './shared';
const SEARCH_URL = 'https://music.163.com/api/search/get'; const SEARCH_URL = 'https://music.163.com/api/search/get';
const LYRICS_URL = 'https://music.163.com/api/song/lyric'; const LYRICS_URL = 'https://music.163.com/api/song/lyric';
// Adapted from https://github.com/NyaomiDEV/Sunamu/blob/master/src/main/lyricproviders/netease.ts // Adapted from https://github.com/NyaomiDEV/Sunamu/blob/master/src/main/lyricproviders/netease.ts
export interface NetEaseResponse {
code: number;
result: Result;
}
export interface Result { export interface Result {
hasMore: boolean; hasMore: boolean;
songCount: number; songCount: number;
@ -35,13 +31,13 @@ export interface Song {
mark: number; mark: number;
mvid: number; mvid: number;
name: string; name: string;
rUrl: null;
rtype: number; rtype: number;
rUrl: null;
status: number; status: number;
transNames?: string[]; transNames?: string[];
} }
export interface Album { interface Album {
artist: Artist; artist: Artist;
copyrightId: number; copyrightId: number;
id: number; id: number;
@ -54,7 +50,7 @@ export interface Album {
transNames?: string[]; transNames?: string[];
} }
export interface Artist { interface Artist {
albumSize: number; albumSize: number;
alias: any[]; alias: any[];
fansGroup: null; fansGroup: null;
@ -67,6 +63,29 @@ export interface Artist {
trans: null; trans: null;
} }
interface NetEaseResponse {
code: number;
result: Result;
}
export async function getLyricsBySongId(songId: string): Promise<null | string> {
let result: AxiosResponse<any, any>;
try {
result = await axios.get(LYRICS_URL, {
params: {
id: songId,
kv: '-1',
lv: '-1',
},
});
} catch (e) {
console.error('NetEase lyrics request got an error!', e);
return null;
}
return result.data.klyric?.lyric || result.data.lrc?.lyric;
}
export async function getSearchResults( export async function getSearchResults(
params: LyricSearchQuery, params: LyricSearchQuery,
): Promise<InternetProviderLyricSearchResponse[] | null> { ): Promise<InternetProviderLyricSearchResponse[] | null> {
@ -110,38 +129,6 @@ export async function getSearchResults(
return orderSearchResults({ params, results: songResults }); return orderSearchResults({ params, results: songResults });
} }
async function getMatchedLyrics(
params: LyricSearchQuery,
): Promise<Omit<InternetProviderLyricResponse, 'lyrics'> | null> {
const results = await getSearchResults(params);
const firstMatch = results?.[0];
if (!firstMatch || (firstMatch?.score && firstMatch.score > 0.5)) {
return null;
}
return firstMatch;
}
export async function getLyricsBySongId(songId: string): Promise<string | null> {
let result: AxiosResponse<any, any>;
try {
result = await axios.get(LYRICS_URL, {
params: {
id: songId,
kv: '-1',
lv: '-1',
},
});
} catch (e) {
console.error('NetEase lyrics request got an error!', e);
return null;
}
return result.data.klyric?.lyric || result.data.lrc?.lyric;
}
export async function query( export async function query(
params: LyricSearchQuery, params: LyricSearchQuery,
): Promise<InternetProviderLyricResponse | null> { ): Promise<InternetProviderLyricResponse | null> {
@ -165,3 +152,17 @@ export async function query(
source: LyricSource.NETEASE, source: LyricSource.NETEASE,
}; };
} }
async function getMatchedLyrics(
params: LyricSearchQuery,
): Promise<null | Omit<InternetProviderLyricResponse, 'lyrics'>> {
const results = await getSearchResults(params);
const firstMatch = results?.[0];
if (!firstMatch || (firstMatch?.score && firstMatch.score > 0.5)) {
return null;
}
return firstMatch;
}

3
src/main/features/core/lyrics/shared.ts
View file

@ -1,8 +1,9 @@
import Fuse from 'fuse.js'; import Fuse from 'fuse.js';
import { import {
InternetProviderLyricSearchResponse, InternetProviderLyricSearchResponse,
LyricSearchQuery, LyricSearchQuery,
} from '../../../../renderer/api/types'; } from '/@/shared/types/domain-types';
export const orderSearchResults = (args: { export const orderSearchResults = (args: {
params: LyricSearchQuery; params: LyricSearchQuery;

52
src/main/features/core/player/index.ts
View file

@ -1,10 +1,11 @@
import console from 'console'; import console from 'console';
import { rm } from 'fs/promises';
import { pid } from 'node:process';
import { app, ipcMain } from 'electron'; import { app, ipcMain } from 'electron';
import { rm } from 'fs/promises';
import uniq from 'lodash/uniq'; import uniq from 'lodash/uniq';
import MpvAPI from 'node-mpv'; import MpvAPI from 'node-mpv';
import { getMainWindow, sendToastToRenderer } from '../../../main'; import { pid } from 'node:process';
import { getMainWindow, sendToastToRenderer } from '../../../index';
import { createLog, isWindows } from '../../../utils'; import { createLog, isWindows } from '../../../utils';
import { store } from '../settings'; import { store } from '../settings';
@ -86,7 +87,7 @@ const createMpv = async (data: {
extraParameters?: string[]; extraParameters?: string[];
properties?: Record<string, any>; properties?: Record<string, any>;
}): Promise<MpvAPI> => { }): Promise<MpvAPI> => {
const { extraParameters, properties, binaryPath } = data; const { binaryPath, extraParameters, properties } = data;
const params = uniq([...DEFAULT_MPV_PARAMETERS(extraParameters), ...(extraParameters || [])]); const params = uniq([...DEFAULT_MPV_PARAMETERS(extraParameters), ...(extraParameters || [])]);
@ -174,7 +175,7 @@ ipcMain.on('player-set-properties', async (_event, data: Record<string, any>) =>
} else { } else {
getMpvInstance()?.setMultipleProperties(data); getMpvInstance()?.setMultipleProperties(data);
} }
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to set properties: ${JSON.stringify(data)}` }, err); mpvLog({ action: `Failed to set properties: ${JSON.stringify(data)}` }, err);
} }
}); });
@ -199,7 +200,7 @@ ipcMain.handle(
mpvInstance = await createMpv(data); mpvInstance = await createMpv(data);
mpvLog({ action: 'Restarted mpv', toast: 'success' }); mpvLog({ action: 'Restarted mpv', toast: 'success' });
setAudioPlayerFallback(false); setAudioPlayerFallback(false);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to restart mpv, falling back to web player' }, err); mpvLog({ action: 'Failed to restart mpv, falling back to web player' }, err);
setAudioPlayerFallback(true); setAudioPlayerFallback(true);
} }
@ -215,7 +216,7 @@ ipcMain.handle(
}); });
mpvInstance = await createMpv(data); mpvInstance = await createMpv(data);
setAudioPlayerFallback(false); setAudioPlayerFallback(false);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to initialize mpv, falling back to web player' }, err); mpvLog({ action: 'Failed to initialize mpv, falling back to web player' }, err);
setAudioPlayerFallback(true); setAudioPlayerFallback(true);
} }
@ -226,7 +227,7 @@ ipcMain.on('player-quit', async () => {
try { try {
await getMpvInstance()?.stop(); await getMpvInstance()?.stop();
await quit(); await quit();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to quit mpv' }, err); mpvLog({ action: 'Failed to quit mpv' }, err);
} finally { } finally {
mpvInstance = null; mpvInstance = null;
@ -245,7 +246,7 @@ ipcMain.handle('player-clean-up', async () => {
ipcMain.on('player-start', async () => { ipcMain.on('player-start', async () => {
try { try {
await getMpvInstance()?.play(); await getMpvInstance()?.play();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to start mpv playback' }, err); mpvLog({ action: 'Failed to start mpv playback' }, err);
} }
}); });
@ -254,7 +255,7 @@ ipcMain.on('player-start', async () => {
ipcMain.on('player-play', async () => { ipcMain.on('player-play', async () => {
try { try {
await getMpvInstance()?.play(); await getMpvInstance()?.play();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to start mpv playback' }, err); mpvLog({ action: 'Failed to start mpv playback' }, err);
} }
}); });
@ -263,7 +264,7 @@ ipcMain.on('player-play', async () => {
ipcMain.on('player-pause', async () => { ipcMain.on('player-pause', async () => {
try { try {
await getMpvInstance()?.pause(); await getMpvInstance()?.pause();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to pause mpv playback' }, err); mpvLog({ action: 'Failed to pause mpv playback' }, err);
} }
}); });
@ -272,7 +273,7 @@ ipcMain.on('player-pause', async () => {
ipcMain.on('player-stop', async () => { ipcMain.on('player-stop', async () => {
try { try {
await getMpvInstance()?.stop(); await getMpvInstance()?.stop();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to stop mpv playback' }, err); mpvLog({ action: 'Failed to stop mpv playback' }, err);
} }
}); });
@ -281,7 +282,7 @@ ipcMain.on('player-stop', async () => {
ipcMain.on('player-next', async () => { ipcMain.on('player-next', async () => {
try { try {
await getMpvInstance()?.next(); await getMpvInstance()?.next();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to go to next track' }, err); mpvLog({ action: 'Failed to go to next track' }, err);
} }
}); });
@ -290,7 +291,7 @@ ipcMain.on('player-next', async () => {
ipcMain.on('player-previous', async () => { ipcMain.on('player-previous', async () => {
try { try {
await getMpvInstance()?.prev(); await getMpvInstance()?.prev();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: 'Failed to go to previous track' }, err); mpvLog({ action: 'Failed to go to previous track' }, err);
} }
}); });
@ -299,7 +300,7 @@ ipcMain.on('player-previous', async () => {
ipcMain.on('player-seek', async (_event, time: number) => { ipcMain.on('player-seek', async (_event, time: number) => {
try { try {
await getMpvInstance()?.seek(time); await getMpvInstance()?.seek(time);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to seek by ${time} seconds` }, err); mpvLog({ action: `Failed to seek by ${time} seconds` }, err);
} }
}); });
@ -308,7 +309,7 @@ ipcMain.on('player-seek', async (_event, time: number) => {
ipcMain.on('player-seek-to', async (_event, time: number) => { ipcMain.on('player-seek-to', async (_event, time: number) => {
try { try {
await getMpvInstance()?.goToPosition(time); await getMpvInstance()?.goToPosition(time);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to seek to ${time} seconds` }, err); mpvLog({ action: `Failed to seek to ${time} seconds` }, err);
} }
}); });
@ -320,7 +321,7 @@ ipcMain.on('player-set-queue', async (_event, current?: string, next?: string, p
await getMpvInstance()?.clearPlaylist(); await getMpvInstance()?.clearPlaylist();
await getMpvInstance()?.pause(); await getMpvInstance()?.pause();
return; return;
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to clear play queue` }, err); mpvLog({ action: `Failed to clear play queue` }, err);
} }
} }
@ -329,7 +330,8 @@ ipcMain.on('player-set-queue', async (_event, current?: string, next?: string, p
if (current) { if (current) {
try { try {
await getMpvInstance()?.load(current, 'replace'); await getMpvInstance()?.load(current, 'replace');
} catch (error) { } catch (error: any | NodeMpvError) {
mpvLog({ action: `Failed to load current song` }, error);
await getMpvInstance()?.play(); await getMpvInstance()?.play();
} }
@ -344,7 +346,7 @@ ipcMain.on('player-set-queue', async (_event, current?: string, next?: string, p
// Only force play if pause is explicitly false // Only force play if pause is explicitly false
await getMpvInstance()?.play(); await getMpvInstance()?.play();
} }
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to set play queue` }, err); mpvLog({ action: `Failed to set play queue` }, err);
} }
}); });
@ -365,7 +367,7 @@ ipcMain.on('player-set-queue-next', async (_event, url?: string) => {
if (url) { if (url) {
await getMpvInstance()?.load(url, 'append'); await getMpvInstance()?.load(url, 'append');
} }
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to set play queue` }, err); mpvLog({ action: `Failed to set play queue` }, err);
} }
}); });
@ -385,7 +387,7 @@ ipcMain.on('player-auto-next', async (_event, url?: string) => {
if (url) { if (url) {
await getMpvInstance()?.load(url, 'append'); await getMpvInstance()?.load(url, 'append');
} }
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to load next song` }, err); mpvLog({ action: `Failed to load next song` }, err);
} }
}); });
@ -398,7 +400,7 @@ ipcMain.on('player-volume', async (_event, value: number) => {
} }
await getMpvInstance()?.volume(value); await getMpvInstance()?.volume(value);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to set volume to ${value}` }, err); mpvLog({ action: `Failed to set volume to ${value}` }, err);
} }
}); });
@ -407,7 +409,7 @@ ipcMain.on('player-volume', async (_event, value: number) => {
ipcMain.on('player-mute', async (_event, mute: boolean) => { ipcMain.on('player-mute', async (_event, mute: boolean) => {
try { try {
await getMpvInstance()?.mute(mute); await getMpvInstance()?.mute(mute);
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to set mute status` }, err); mpvLog({ action: `Failed to set mute status` }, err);
} }
}); });
@ -415,7 +417,7 @@ ipcMain.on('player-mute', async (_event, mute: boolean) => {
ipcMain.handle('player-get-time', async (): Promise<number | undefined> => { ipcMain.handle('player-get-time', async (): Promise<number | undefined> => {
try { try {
return getMpvInstance()?.getTimePosition(); return getMpvInstance()?.getTimePosition();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to get current time` }, err); mpvLog({ action: `Failed to get current time` }, err);
return 0; return 0;
} }
@ -442,7 +444,7 @@ app.on('before-quit', async (event) => {
event.preventDefault(); event.preventDefault();
await getMpvInstance()?.stop(); await getMpvInstance()?.stop();
await quit(); await quit();
} catch (err: NodeMpvError | any) { } catch (err: any | NodeMpvError) {
mpvLog({ action: `Failed to cleanly before-quit` }, err); mpvLog({ action: `Failed to cleanly before-quit` }, err);
} finally { } finally {
mpvState = MpvState.DONE; mpvState = MpvState.DONE;

2
src/main/features/core/player/media-keys.ts
View file

@ -1,5 +1,5 @@
/* eslint-disable promise/always-return */
import { BrowserWindow, globalShortcut, systemPreferences } from 'electron'; import { BrowserWindow, globalShortcut, systemPreferences } from 'electron';
import { isMacOS } from '../../../utils'; import { isMacOS } from '../../../utils';
import { store } from '../settings'; import { store } from '../settings';

200
src/main/features/core/remote/index.ts
View file

@ -1,23 +1,36 @@
import { Stats, promises } from 'fs';
import { readFile } from 'fs/promises';
import { IncomingMessage, Server, ServerResponse, createServer } from 'http';
import { join } from 'path';
import { deflate, gzip } from 'zlib';
import axios from 'axios'; import axios from 'axios';
import { app, ipcMain } from 'electron'; import { app, ipcMain } from 'electron';
import { Server as WsServer, WebSocketServer, WebSocket } from 'ws'; import { promises, Stats } from 'fs';
import { readFile } from 'fs/promises';
import { createServer, IncomingMessage, Server, ServerResponse } from 'http';
import { join } from 'path';
import { WebSocket, WebSocketServer, Server as WsServer } from 'ws';
import { deflate, gzip } from 'zlib';
import manifest from './manifest.json'; import manifest from './manifest.json';
import { ClientEvent, ServerEvent } from '../../../../remote/types';
import { PlayerRepeat, PlayerStatus, SongState } from '../../../../renderer/types'; import { getMainWindow } from '/@/main/index';
import { getMainWindow } from '../../../main'; import { isLinux } from '/@/main/utils';
import { isLinux } from '../../../utils'; import { QueueSong } from '/@/shared/types/domain-types';
import type { QueueSong } from '/@/renderer/api/types'; import { ClientEvent, ServerEvent } from '/@/shared/types/remote-types';
import { PlayerRepeat, PlayerStatus, SongState } from '/@/shared/types/types';
let mprisPlayer: any | undefined; let mprisPlayer: any | undefined;
if (isLinux()) { async function initMpris() {
// eslint-disable-next-line global-require if (isLinux()) {
mprisPlayer = require('../../linux/mpris').mprisPlayer; const mpris = await import('../../linux/mpris');
mprisPlayer = mpris.mprisPlayer;
}
}
initMpris();
interface MimeType {
css: string;
html: string;
ico: string;
js: string;
} }
interface RemoteConfig { interface RemoteConfig {
@ -27,21 +40,13 @@ interface RemoteConfig {
username: string; username: string;
} }
interface MimeType {
css: string;
html: string;
ico: string;
js: string;
}
declare class StatefulWebSocket extends WebSocket { declare class StatefulWebSocket extends WebSocket {
alive: boolean; alive: boolean;
auth: boolean; auth: boolean;
} }
let server: Server | undefined; let server: Server | undefined;
let wsServer: WsServer<typeof StatefulWebSocket> | undefined; let wsServer: undefined | WsServer<typeof StatefulWebSocket>;
const settings: RemoteConfig = { const settings: RemoteConfig = {
enabled: false, enabled: false,
@ -54,14 +59,6 @@ type SendData = ServerEvent & {
client: StatefulWebSocket; client: StatefulWebSocket;
}; };
function send({ client, event, data }: SendData): void {
if (client.readyState === WebSocket.OPEN) {
if (client.alive && client.auth) {
client.send(JSON.stringify({ data, event }));
}
}
}
function broadcast(message: ServerEvent): void { function broadcast(message: ServerEvent): void {
if (wsServer) { if (wsServer) {
for (const client of wsServer.clients) { for (const client of wsServer.clients) {
@ -70,6 +67,14 @@ function broadcast(message: ServerEvent): void {
} }
} }
function send({ client, data, event }: SendData): void {
if (client.readyState === WebSocket.OPEN) {
if (client.alive && client.auth) {
client.send(JSON.stringify({ data, event }));
}
}
}
const shutdownServer = () => { const shutdownServer = () => {
if (wsServer) { if (wsServer) {
wsServer.clients.forEach((client) => client.close(4000)); wsServer.clients.forEach((client) => client.close(4000));
@ -121,21 +126,17 @@ const getEncoding = (encoding: string | string[]): Encoding => {
const cache = new Map<string, Map<Encoding, [number, Buffer]>>(); const cache = new Map<string, Map<Encoding, [number, Buffer]>>();
function setOk( function authorize(req: IncomingMessage): boolean {
res: ServerResponse, if (settings.username || settings.password) {
mtimeMs: number, // https://stackoverflow.com/questions/23616371/basic-http-authentication-with-node-and-express-4
extension: keyof MimeType,
encoding: Encoding,
data?: Buffer,
) {
res.statusCode = data ? 200 : 304;
res.setHeader('Content-Type', MIME_TYPES[extension]); const authorization = req.headers.authorization?.split(' ')[1] || '';
res.setHeader('ETag', `"${mtimeMs}"`); const [login, password] = Buffer.from(authorization, 'base64').toString().split(':');
res.setHeader('Cache-Control', 'public');
if (encoding !== 'none') res.setHeader('Content-Encoding', encoding); return login === settings.username && password === settings.password;
res.end(data); }
return true;
} }
async function serveFile( async function serveFile(
@ -147,7 +148,7 @@ async function serveFile(
const fileName = `${file}.${extension}`; const fileName = `${file}.${extension}`;
const path = app.isPackaged const path = app.isPackaged
? join(__dirname, '../remote', fileName) ? join(__dirname, '../remote', fileName)
: join(__dirname, '../../../../../.erb/dll', fileName); : join(__dirname, '../../dist/remote', fileName);
let stats: Stats; let stats: Stats;
@ -252,17 +253,21 @@ async function serveFile(
return Promise.resolve(); return Promise.resolve();
} }
function authorize(req: IncomingMessage): boolean { function setOk(
if (settings.username || settings.password) { res: ServerResponse,
// https://stackoverflow.com/questions/23616371/basic-http-authentication-with-node-and-express-4 mtimeMs: number,
extension: keyof MimeType,
encoding: Encoding,
data?: Buffer,
) {
res.statusCode = data ? 200 : 304;
const authorization = req.headers.authorization?.split(' ')[1] || ''; res.setHeader('Content-Type', MIME_TYPES[extension]);
const [login, password] = Buffer.from(authorization, 'base64').toString().split(':'); res.setHeader('ETag', `"${mtimeMs}"`);
res.setHeader('Cache-Control', 'public');
return login === settings.username && password === settings.password; if (encoding !== 'none') res.setHeader('Content-Encoding', encoding);
} res.end(data);
return true;
} }
const enableServer = (config: RemoteConfig): Promise<void> => { const enableServer = (config: RemoteConfig): Promise<void> => {
@ -286,28 +291,28 @@ const enableServer = (config: RemoteConfig): Promise<void> => {
await serveFile(req, 'index', 'html', res); await serveFile(req, 'index', 'html', res);
break; break;
} }
case '/credentials': {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end(req.headers.authorization);
break;
}
case '/favicon.ico': { case '/favicon.ico': {
await serveFile(req, 'favicon', 'ico', res); await serveFile(req, 'favicon', 'ico', res);
break; break;
} }
case '/remote.css': {
await serveFile(req, 'remote', 'css', res);
break;
}
case '/remote.js': {
await serveFile(req, 'remote', 'js', res);
break;
}
case '/manifest.json': { case '/manifest.json': {
res.statusCode = 200; res.statusCode = 200;
res.setHeader('Content-Type', 'application/json'); res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify(manifest)); res.end(JSON.stringify(manifest));
break; break;
} }
case '/credentials': { case '/remote.css': {
res.statusCode = 200; await serveFile(req, 'remote', 'css', res);
res.setHeader('Content-Type', 'text/plain'); break;
res.end(req.headers.authorization); }
case '/remote.js': {
await serveFile(req, 'remote', 'js', res);
break; break;
} }
default: { default: {
@ -371,6 +376,21 @@ const enableServer = (config: RemoteConfig): Promise<void> => {
} }
switch (event) { switch (event) {
case 'favorite': {
const { favorite, id } = json;
if (id && id === currentState.song?.id) {
getMainWindow()?.webContents.send('request-favorite', {
favorite,
id,
serverId: currentState.song.serverId,
});
}
break;
}
case 'next': {
getMainWindow()?.webContents.send('renderer-player-next');
break;
}
case 'pause': { case 'pause': {
getMainWindow()?.webContents.send('renderer-player-pause'); getMainWindow()?.webContents.send('renderer-player-pause');
break; break;
@ -379,10 +399,6 @@ const enableServer = (config: RemoteConfig): Promise<void> => {
getMainWindow()?.webContents.send('renderer-player-play'); getMainWindow()?.webContents.send('renderer-player-play');
break; break;
} }
case 'next': {
getMainWindow()?.webContents.send('renderer-player-next');
break;
}
case 'previous': { case 'previous': {
getMainWindow()?.webContents.send('renderer-player-previous'); getMainWindow()?.webContents.send('renderer-player-previous');
break; break;
@ -421,6 +437,17 @@ const enableServer = (config: RemoteConfig): Promise<void> => {
break; break;
} }
case 'rating': {
const { id, rating } = json;
if (id && id === currentState.song?.id) {
getMainWindow()?.webContents.send('request-rating', {
id,
rating,
serverId: currentState.song.serverId,
});
}
break;
}
case 'repeat': { case 'repeat': {
getMainWindow()?.webContents.send('renderer-player-toggle-repeat'); getMainWindow()?.webContents.send('renderer-player-toggle-repeat');
break; break;
@ -450,28 +477,6 @@ const enableServer = (config: RemoteConfig): Promise<void> => {
} }
break; break;
} }
case 'favorite': {
const { favorite, id } = json;
if (id && id === currentState.song?.id) {
getMainWindow()?.webContents.send('request-favorite', {
favorite,
id,
serverId: currentState.song.serverId,
});
}
break;
}
case 'rating': {
const { rating, id } = json;
if (id && id === currentState.song?.id) {
getMainWindow()?.webContents.send('request-rating', {
id,
rating,
serverId: currentState.song.serverId,
});
}
break;
}
case 'position': { case 'position': {
const { position } = json; const { position } = json;
if (mprisPlayer) { if (mprisPlayer) {
@ -631,15 +636,10 @@ ipcMain.on('update-volume', (_event, volume: number) => {
if (mprisPlayer) { if (mprisPlayer) {
mprisPlayer.on('loopStatus', (event: string) => { mprisPlayer.on('loopStatus', (event: string) => {
const repeat = const repeat = event === 'Playlist' ? 'all' : event === 'Track' ? 'one' : 'none';
event === 'Playlist'
? PlayerRepeat.ALL
: event === 'Track'
? PlayerRepeat.ONE
: PlayerRepeat.NONE;
currentState.repeat = repeat; currentState.repeat = repeat as PlayerRepeat;
broadcast({ data: repeat, event: 'repeat' }); broadcast({ data: repeat, event: 'repeat' } as ServerEvent);
}); });
mprisPlayer.on('shuffle', (shuffle: boolean) => { mprisPlayer.on('shuffle', (shuffle: boolean) => {

5
src/main/features/core/settings/index.ts
View file

@ -1,6 +1,7 @@
import type { TitleTheme } from '/@/shared/types/types';
import { ipcMain, nativeTheme, safeStorage } from 'electron'; import { ipcMain, nativeTheme, safeStorage } from 'electron';
import Store from 'electron-store'; import Store from 'electron-store';
import type { TitleTheme } from '/@/renderer/types';
export const store = new Store(); export const store = new Store();
@ -12,7 +13,7 @@ ipcMain.on('settings-set', (__event, data: { property: string; value: any }) =>
store.set(`${data.property}`, data.value); store.set(`${data.property}`, data.value);
}); });
ipcMain.handle('password-get', (_event, server: string): string | null => { ipcMain.handle('password-get', (_event, server: string): null | string => {
if (safeStorage.isEncryptionAvailable()) { if (safeStorage.isEncryptionAvailable()) {
const servers = store.get('server') as Record<string, string> | undefined; const servers = store.get('server') as Record<string, string> | undefined;

4
src/main/features/index.ts
View file

@ -1,4 +1,2 @@
import './core'; import './core';
import(`./${process.platform}`);
// eslint-disable-next-line import/no-dynamic-require
require(`./${process.platform}`);

9
src/main/features/linux/mpris.ts
View file

@ -1,8 +1,9 @@
import { ipcMain } from 'electron'; import { ipcMain } from 'electron';
import Player from 'mpris-service'; import Player from 'mpris-service';
import { PlayerRepeat, PlayerStatus } from '../../../renderer/types';
import { getMainWindow } from '../../main'; import { getMainWindow } from '/@/main/index';
import { QueueSong } from '/@/renderer/api/types'; import { QueueSong } from '/@/shared/types/domain-types';
import { PlayerRepeat, PlayerStatus } from '/@/shared/types/types';
const mprisPlayer = Player({ const mprisPlayer = Player({
identity: 'Feishin', identity: 'Feishin',
@ -124,8 +125,8 @@ ipcMain.on('update-playback', (_event, status: PlayerStatus) => {
const REPEAT_TO_MPRIS: Record<PlayerRepeat, string> = { const REPEAT_TO_MPRIS: Record<PlayerRepeat, string> = {
[PlayerRepeat.ALL]: 'Playlist', [PlayerRepeat.ALL]: 'Playlist',
[PlayerRepeat.ONE]: 'Track',
[PlayerRepeat.NONE]: 'None', [PlayerRepeat.NONE]: 'None',
[PlayerRepeat.ONE]: 'Track',
}; };
ipcMain.on('update-repeat', (_event, arg: PlayerRepeat) => { ipcMain.on('update-repeat', (_event, arg: PlayerRepeat) => {

130
src/main/main.ts → src/main/index.ts
View file

@ -1,51 +1,41 @@
/* eslint global-require: off, no-console: off, promise/always-return: off */ import { is } from '@electron-toolkit/utils';
/**
* This module executes inside of electron's main process. You can start
* electron renderer process from here and communicate with the other processes
* through IPC.
*
* When running `npm run build` or `npm run build:main`, this file is compiled to
* `./src/main.js` using webpack. This gives us some performance wins.
*/
import { access, constants, readFile, writeFile } from 'fs';
import path, { join } from 'path';
import { deflate, inflate } from 'zlib';
import { import {
app, app,
BrowserWindow, BrowserWindow,
shell, BrowserWindowConstructorOptions,
ipcMain,
globalShortcut, globalShortcut,
Tray, ipcMain,
Menu, Menu,
nativeImage, nativeImage,
nativeTheme, nativeTheme,
BrowserWindowConstructorOptions,
protocol,
net, net,
protocol,
Rectangle, Rectangle,
screen, screen,
shell,
Tray,
} from 'electron'; } from 'electron';
import electronLocalShortcut from 'electron-localshortcut'; import electronLocalShortcut from 'electron-localshortcut';
import log from 'electron-log/main'; import log from 'electron-log/main';
import { autoUpdater } from 'electron-updater'; import { autoUpdater } from 'electron-updater';
import { access, constants, readFile, writeFile } from 'fs';
import path, { join } from 'path';
import { deflate, inflate } from 'zlib';
import { disableMediaKeys, enableMediaKeys } from './features/core/player/media-keys'; import { disableMediaKeys, enableMediaKeys } from './features/core/player/media-keys';
import { store } from './features/core/settings/index'; import { store } from './features/core/settings';
import MenuBuilder from './menu'; import MenuBuilder from './menu';
import { import {
autoUpdaterLogInterface,
createLog,
hotkeyToElectronAccelerator, hotkeyToElectronAccelerator,
isLinux, isLinux,
isMacOS, isMacOS,
isWindows, isWindows,
resolveHtmlPath,
createLog,
autoUpdaterLogInterface,
} from './utils'; } from './utils';
import './features'; import './features';
import type { TitleTheme } from '/@/renderer/types';
declare module 'node-mpv'; import { TitleTheme } from '/@/shared/types/types';
export default class AppUpdater { export default class AppUpdater {
constructor() { constructor() {
@ -72,34 +62,51 @@ if (isLinux() && !process.argv.some((a) => a.startsWith('--password-store='))) {
} }
let mainWindow: BrowserWindow | null = null; let mainWindow: BrowserWindow | null = null;
let tray: Tray | null = null; let tray: null | Tray = null;
let exitFromTray = false; let exitFromTray = false;
let forceQuit = false; let forceQuit = false;
if (process.env.NODE_ENV === 'production') { if (process.env.NODE_ENV === 'production') {
const sourceMapSupport = require('source-map-support'); import('source-map-support').then((sourceMapSupport) => {
sourceMapSupport.install(); sourceMapSupport.install();
});
} }
const isDevelopment = process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true'; const isDevelopment = process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true';
if (isDevelopment) { if (isDevelopment) {
require('electron-debug')(); import('electron-debug').then((electronDebug) => {
electronDebug.default();
});
} }
const installExtensions = async () => { const installExtensions = async () => {
const installer = require('electron-devtools-installer'); import('electron-devtools-installer').then((installer) => {
const forceDownload = !!process.env.UPGRADE_EXTENSIONS; const forceDownload = !!process.env.UPGRADE_EXTENSIONS;
const extensions = ['REACT_DEVELOPER_TOOLS', 'REDUX_DEVTOOLS']; const extensions = ['REACT_DEVELOPER_TOOLS', 'REDUX_DEVTOOLS'];
return installer return installer
.default( .default(
extensions.map((name) => installer[name]), extensions.map((name) => installer[name]),
forceDownload, forceDownload,
) )
.catch(console.log); .then((installedExtensions) => {
createLog({
message: `Installed extension: ${installedExtensions}`,
type: 'info',
});
})
.catch(console.error);
});
}; };
const userDataPath = app.getPath('userData');
if (isDevelopment) {
const devUserDataPath = `${userDataPath}-dev`;
app.setPath('userData', devUserDataPath);
}
const RESOURCES_PATH = app.isPackaged const RESOURCES_PATH = app.isPackaged
? path.join(process.resourcesPath, 'assets') ? path.join(process.resourcesPath, 'assets')
: path.join(__dirname, '../../assets'); : path.join(__dirname, '../../assets');
@ -117,7 +124,7 @@ export const sendToastToRenderer = ({
type, type,
}: { }: {
message: string; message: string;
type: 'success' | 'error' | 'warning' | 'info'; type: 'error' | 'info' | 'success' | 'warning';
}) => { }) => {
getMainWindow()?.webContents.send('toast-from-main', { getMainWindow()?.webContents.send('toast-from-main', {
message, message,
@ -208,7 +215,7 @@ const createTray = () => {
tray.setContextMenu(contextMenu); tray.setContextMenu(contextMenu);
}; };
const createWindow = async (first = true) => { async function createWindow(first = true): Promise<void> {
if (isDevelopment) { if (isDevelopment) {
await installExtensions().catch(console.log); await installExtensions().catch(console.log);
} }
@ -233,6 +240,7 @@ const createWindow = async (first = true) => {
}, },
}; };
// Create the browser window.
mainWindow = new BrowserWindow({ mainWindow = new BrowserWindow({
autoHideMenuBar: true, autoHideMenuBar: true,
frame: false, frame: false,
@ -247,9 +255,8 @@ const createWindow = async (first = true) => {
contextIsolation: true, contextIsolation: true,
devTools: true, devTools: true,
nodeIntegration: true, nodeIntegration: true,
preload: app.isPackaged preload: join(__dirname, '../preload/index.js'),
? path.join(__dirname, 'preload.js') sandbox: false,
: path.join(__dirname, '../../.erb/dll/preload.js'),
webSecurity: !store.get('ignore_cors'), webSecurity: !store.get('ignore_cors'),
}, },
width: 1440, width: 1440,
@ -374,11 +381,11 @@ const createWindow = async (first = true) => {
enableMediaKeys(mainWindow); enableMediaKeys(mainWindow);
} }
mainWindow.loadURL(resolveHtmlPath('index.html'));
const startWindowMinimized = store.get('window_start_minimized', false) as boolean; const startWindowMinimized = store.get('window_start_minimized', false) as boolean;
mainWindow.on('ready-to-show', () => { mainWindow.on('ready-to-show', () => {
// mainWindow.show()
if (!mainWindow) { if (!mainWindow) {
throw new Error('"mainWindow" is not defined'); throw new Error('"mainWindow" is not defined');
} }
@ -457,7 +464,7 @@ const createWindow = async (first = true) => {
} }
}); });
mainWindow.on('minimize', (event: any) => { (mainWindow as any).on('minimize', (event: any) => {
if (store.get('window_minimize_to_tray') === true) { if (store.get('window_minimize_to_tray') === true) {
event.preventDefault(); event.preventDefault();
mainWindow?.hide(); mainWindow?.hide();
@ -484,13 +491,25 @@ const createWindow = async (first = true) => {
}); });
if (store.get('disable_auto_updates') !== true) { if (store.get('disable_auto_updates') !== true) {
// eslint-disable-next-line
new AppUpdater(); new AppUpdater();
} }
const theme = store.get('theme') as TitleTheme | undefined; const theme = store.get('theme') as TitleTheme | undefined;
nativeTheme.themeSource = theme || 'dark'; nativeTheme.themeSource = theme || 'dark';
};
mainWindow.webContents.setWindowOpenHandler((details) => {
shell.openExternal(details.url);
return { action: 'deny' };
});
// HMR for renderer base on electron-vite cli.
// Load the remote URL for development or the local html file for production.
if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL']);
} else {
mainWindow.loadFile(join(__dirname, '../renderer/index.html'));
}
}
app.commandLine.appendSwitch('disable-features', 'HardwareMediaKeyHandling,MediaSessionService'); app.commandLine.appendSwitch('disable-features', 'HardwareMediaKeyHandling,MediaSessionService');
@ -519,6 +538,8 @@ enum BindingActions {
} }
const HOTKEY_ACTIONS: Record<BindingActions, () => void> = { const HOTKEY_ACTIONS: Record<BindingActions, () => void> = {
[BindingActions.GLOBAL_SEARCH]: () => {},
[BindingActions.LOCAL_SEARCH]: () => {},
[BindingActions.MUTE]: () => getMainWindow()?.webContents.send('renderer-player-volume-mute'), [BindingActions.MUTE]: () => getMainWindow()?.webContents.send('renderer-player-volume-mute'),
[BindingActions.NEXT]: () => getMainWindow()?.webContents.send('renderer-player-next'), [BindingActions.NEXT]: () => getMainWindow()?.webContents.send('renderer-player-next'),
[BindingActions.PAUSE]: () => getMainWindow()?.webContents.send('renderer-player-pause'), [BindingActions.PAUSE]: () => getMainWindow()?.webContents.send('renderer-player-pause'),
@ -533,16 +554,14 @@ const HOTKEY_ACTIONS: Record<BindingActions, () => void> = {
[BindingActions.SKIP_FORWARD]: () => [BindingActions.SKIP_FORWARD]: () =>
getMainWindow()?.webContents.send('renderer-player-skip-forward'), getMainWindow()?.webContents.send('renderer-player-skip-forward'),
[BindingActions.STOP]: () => getMainWindow()?.webContents.send('renderer-player-stop'), [BindingActions.STOP]: () => getMainWindow()?.webContents.send('renderer-player-stop'),
[BindingActions.TOGGLE_FULLSCREEN_PLAYER]: () => {},
[BindingActions.TOGGLE_QUEUE]: () => {},
[BindingActions.TOGGLE_REPEAT]: () => [BindingActions.TOGGLE_REPEAT]: () =>
getMainWindow()?.webContents.send('renderer-player-toggle-repeat'), getMainWindow()?.webContents.send('renderer-player-toggle-repeat'),
[BindingActions.VOLUME_UP]: () =>
getMainWindow()?.webContents.send('renderer-player-volume-up'),
[BindingActions.VOLUME_DOWN]: () => [BindingActions.VOLUME_DOWN]: () =>
getMainWindow()?.webContents.send('renderer-player-volume-down'), getMainWindow()?.webContents.send('renderer-player-volume-down'),
[BindingActions.GLOBAL_SEARCH]: () => {}, [BindingActions.VOLUME_UP]: () =>
[BindingActions.LOCAL_SEARCH]: () => {}, getMainWindow()?.webContents.send('renderer-player-volume-up'),
[BindingActions.TOGGLE_QUEUE]: () => {},
[BindingActions.TOGGLE_FULLSCREEN_PLAYER]: () => {},
}; };
ipcMain.on( ipcMain.on(
@ -585,7 +604,7 @@ ipcMain.on(
_event, _event,
data: { data: {
message: string; message: string;
type: 'debug' | 'verbose' | 'success' | 'error' | 'warning' | 'info'; type: 'debug' | 'error' | 'info' | 'success' | 'verbose' | 'warning';
}, },
) => { ) => {
createLog(data); createLog(data);
@ -597,7 +616,6 @@ app.on('window-all-closed', () => {
// Respect the OSX convention of having the application in memory even // Respect the OSX convention of having the application in memory even
// after all windows have been closed // after all windows have been closed
if (isMacOS()) { if (isMacOS()) {
ipcMain.removeHandler('window-clear-cache');
mainWindow = null; mainWindow = null;
} else { } else {
app.quit(); app.quit();
@ -613,7 +631,7 @@ const FONT_HEADERS = [
'font/woff2', 'font/woff2',
]; ];
const singleInstance = app.requestSingleInstanceLock(); const singleInstance = isDevelopment ? true : app.requestSingleInstanceLock();
if (!singleInstance) { if (!singleInstance) {
app.quit(); app.quit();

64
src/main/menu.ts
View file

@ -1,4 +1,4 @@
import { app, Menu, shell, BrowserWindow, MenuItemConstructorOptions } from 'electron'; import { app, BrowserWindow, Menu, MenuItemConstructorOptions, shell } from 'electron';
interface DarwinMenuItemConstructorOptions extends MenuItemConstructorOptions { interface DarwinMenuItemConstructorOptions extends MenuItemConstructorOptions {
selector?: string; selector?: string;
@ -12,37 +12,6 @@ export default class MenuBuilder {
this.mainWindow = mainWindow; this.mainWindow = mainWindow;
} }
buildMenu(): Menu {
if (process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true') {
this.setupDevelopmentEnvironment();
}
const template =
process.platform === 'darwin'
? this.buildDarwinTemplate()
: this.buildDefaultTemplate();
const menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);
return menu;
}
setupDevelopmentEnvironment(): void {
this.mainWindow.webContents.on('context-menu', (_, props) => {
const { x, y } = props;
Menu.buildFromTemplate([
{
click: () => {
this.mainWindow.webContents.inspectElement(x, y);
},
label: 'Inspect element',
},
]).popup({ window: this.mainWindow });
});
}
buildDarwinTemplate(): MenuItemConstructorOptions[] { buildDarwinTemplate(): MenuItemConstructorOptions[] {
const subMenuAbout: DarwinMenuItemConstructorOptions = { const subMenuAbout: DarwinMenuItemConstructorOptions = {
label: 'Electron', label: 'Electron',
@ -276,4 +245,35 @@ export default class MenuBuilder {
return templateDefault; return templateDefault;
} }
buildMenu(): Menu {
if (process.env.NODE_ENV === 'development' || process.env.DEBUG_PROD === 'true') {
this.setupDevelopmentEnvironment();
}
const template =
process.platform === 'darwin'
? this.buildDarwinTemplate()
: this.buildDefaultTemplate();
const menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);
return menu;
}
setupDevelopmentEnvironment(): void {
this.mainWindow.webContents.on('context-menu', (_, props) => {
const { x, y } = props;
Menu.buildFromTemplate([
{
click: () => {
this.mainWindow.webContents.inspectElement(x, y);
},
label: 'Inspect element',
},
]).popup({ window: this.mainWindow });
});
}
} }

23
src/main/preload.ts
View file

@ -1,23 +0,0 @@
import { contextBridge } from 'electron';
import { browser } from './preload/browser';
import { discordRpc } from './preload/discord-rpc';
import { ipc } from './preload/ipc';
import { localSettings } from './preload/local-settings';
import { lyrics } from './preload/lyrics';
import { mpris } from './preload/mpris';
import { mpvPlayer, mpvPlayerListener } from './preload/mpv-player';
import { remote } from './preload/remote';
import { utils } from './preload/utils';
contextBridge.exposeInMainWorld('electron', {
browser,
discordRpc,
ipc,
localSettings,
lyrics,
mpris,
mpvPlayer,
mpvPlayerListener,
remote,
utils,
});

5
src/main/utils.ts
View file

@ -1,8 +1,7 @@
/* eslint import/prefer-default-export: off, import/no-mutable-exports: off */ import log from 'electron-log/main';
import path from 'path'; import path from 'path';
import process from 'process'; import process from 'process';
import { URL } from 'url'; import { URL } from 'url';
import log from 'electron-log/main';
export let resolveHtmlPath: (htmlFileName: string) => string; export let resolveHtmlPath: (htmlFileName: string) => string;
@ -76,7 +75,7 @@ const logColor = {
export const createLog = (data: { export const createLog = (data: {
message: string; message: string;
type: 'debug' | 'verbose' | 'success' | 'error' | 'warning' | 'info'; type: 'debug' | 'error' | 'info' | 'success' | 'verbose' | 'warning';
}) => { }) => {
logMethod[data.type](`%c${data.message}`, `color: ${logColor[data.type]}`); logMethod[data.type](`%c${data.message}`, `color: ${logColor[data.type]}`);
}; };

0
src/main/preload/browser.ts → src/preload/browser.ts
View file

0
src/main/preload/discord-rpc.ts → src/preload/discord-rpc.ts
View file

15
src/preload/index.d.ts vendored Normal file
View file

@ -0,0 +1,15 @@
import { ElectronAPI } from '@electron-toolkit/preload';
import { PreloadApi } from './index';
declare global {
interface Window {
api: PreloadApi;
electron: ElectronAPI;
queryLocalFonts?: () => Promise<Font[]>;
SERVER_LOCK?: boolean;
SERVER_NAME?: string;
SERVER_TYPE?: ServerType;
SERVER_URL?: string;
}
}

45
src/preload/index.ts Normal file
View file

@ -0,0 +1,45 @@
import { electronAPI } from '@electron-toolkit/preload';
import { contextBridge } from 'electron';
import { browser } from './browser';
import { discordRpc } from './discord-rpc';
import { ipc } from './ipc';
import { localSettings } from './local-settings';
import { lyrics } from './lyrics';
import { mpris } from './mpris';
import { mpvPlayer, mpvPlayerListener } from './mpv-player';
import { remote } from './remote';
import { utils } from './utils';
// Custom APIs for renderer
const api = {
browser,
discordRpc,
ipc,
localSettings,
lyrics,
mpris,
mpvPlayer,
mpvPlayerListener,
remote,
utils,
};
export type PreloadApi = typeof api;
// Use `contextBridge` APIs to expose Electron APIs to
// renderer only if context isolation is enabled, otherwise
// just add to the DOM global.
if (process.contextIsolated) {
try {
contextBridge.exposeInMainWorld('electron', electronAPI);
contextBridge.exposeInMainWorld('api', api);
} catch (error) {
console.error(error);
}
} else {
// @ts-ignore (define in dts)
window.electron = electronAPI;
// @ts-ignore (define in dts)
window.api = api;
}

0
src/main/preload/ipc.ts → src/preload/ipc.ts
View file

22
src/main/preload/local-settings.ts → src/preload/local-settings.ts
View file

@ -1,12 +1,13 @@
import { IpcRendererEvent, ipcRenderer, webFrame } from 'electron'; import { ipcRenderer, IpcRendererEvent, webFrame } from 'electron';
import Store from 'electron-store'; import Store from 'electron-store';
import { toServerType, type TitleTheme } from '/@/renderer/types';
import { TitleTheme } from '/@/shared/types/types';
const store = new Store(); const store = new Store();
const set = ( const set = (
property: string, property: string,
value: string | Record<string, unknown> | boolean | string[] | undefined, value: boolean | Record<string, unknown> | string | string[] | undefined,
) => { ) => {
if (value === undefined) { if (value === undefined) {
store.delete(property); store.delete(property);
@ -32,7 +33,7 @@ const disableMediaKeys = () => {
ipcRenderer.send('global-media-keys-disable'); ipcRenderer.send('global-media-keys-disable');
}; };
const passwordGet = async (server: string): Promise<string | null> => { const passwordGet = async (server: string): Promise<null | string> => {
return ipcRenderer.invoke('password-get', server); return ipcRenderer.invoke('password-get', server);
}; };
@ -56,6 +57,19 @@ const themeSet = (theme: TitleTheme): void => {
ipcRenderer.send('theme-set', theme); ipcRenderer.send('theme-set', theme);
}; };
export const toServerType = (value?: string): null | string => {
switch (value?.toLowerCase()) {
case 'jellyfin':
return 'jellyfin';
case 'navidrome':
return 'navidrome';
case 'subsonic':
return 'subsonic';
default:
return null;
}
};
const SERVER_TYPE = toServerType(process.env.SERVER_TYPE); const SERVER_TYPE = toServerType(process.env.SERVER_TYPE);
const env = { const env = {

6
src/main/preload/lyrics.ts → src/preload/lyrics.ts
View file

@ -1,11 +1,13 @@
import { ipcRenderer } from 'electron'; import { ipcRenderer } from 'electron';
import { import {
InternetProviderLyricSearchResponse, InternetProviderLyricSearchResponse,
LyricGetQuery, LyricGetQuery,
LyricSearchQuery, LyricSearchQuery,
LyricSource, LyricSource,
QueueSong, } from '../main/features/core/lyrics';
} from '/@/renderer/api/types';
import { QueueSong } from '/@/shared/types/domain-types';
const getRemoteLyricsBySong = (song: QueueSong) => { const getRemoteLyricsBySong = (song: QueueSong) => {
const result = ipcRenderer.invoke('lyric-by-song', song); const result = ipcRenderer.invoke('lyric-by-song', song);

5
src/main/preload/mpris.ts → src/preload/mpris.ts
View file

@ -1,5 +1,6 @@
import { IpcRendererEvent, ipcRenderer } from 'electron'; import { ipcRenderer, IpcRendererEvent } from 'electron';
import type { PlayerRepeat } from '/@/renderer/types';
import { PlayerRepeat } from '/@/shared/types/types';
const updatePosition = (timeSec: number) => { const updatePosition = (timeSec: number) => {
ipcRenderer.send('mpris-update-position', timeSec); ipcRenderer.send('mpris-update-position', timeSec);

5
src/main/preload/mpv-player.ts → src/preload/mpv-player.ts
View file

@ -1,5 +1,6 @@
import { ipcRenderer, IpcRendererEvent } from 'electron'; import { ipcRenderer, IpcRendererEvent } from 'electron';
import { PlayerData } from '/@/renderer/store';
import { PlayerData } from '/@/shared/types/domain-types';
const initialize = (data: { extraParameters?: string[]; properties?: Record<string, any> }) => { const initialize = (data: { extraParameters?: string[]; properties?: Record<string, any> }) => {
return ipcRenderer.invoke('player-initialize', data); return ipcRenderer.invoke('player-initialize', data);
@ -187,8 +188,8 @@ export const mpvPlayerListener = {
rendererNext, rendererNext,
rendererPause, rendererPause,
rendererPlay, rendererPlay,
rendererPlayPause,
rendererPlayerFallback, rendererPlayerFallback,
rendererPlayPause,
rendererPrevious, rendererPrevious,
rendererQuit, rendererQuit,
rendererSkipBackward, rendererSkipBackward,

13
src/main/preload/remote.ts → src/preload/remote.ts
View file

@ -1,6 +1,7 @@
import { IpcRendererEvent, ipcRenderer } from 'electron'; import { ipcRenderer, IpcRendererEvent } from 'electron';
import { QueueSong } from '/@/renderer/api/types';
import { PlayerStatus } from '/@/renderer/types'; import { QueueSong } from '/@/shared/types/domain-types';
import { PlayerStatus } from '/@/shared/types/types';
const requestFavorite = ( const requestFavorite = (
cb: ( cb: (
@ -29,12 +30,12 @@ const requestVolume = (cb: (event: IpcRendererEvent, data: { volume: number }) =
ipcRenderer.on('request-volume', cb); ipcRenderer.on('request-volume', cb);
}; };
const setRemoteEnabled = (enabled: boolean): Promise<string | null> => { const setRemoteEnabled = (enabled: boolean): Promise<null | string> => {
const result = ipcRenderer.invoke('remote-enable', enabled); const result = ipcRenderer.invoke('remote-enable', enabled);
return result; return result;
}; };
const setRemotePort = (port: number): Promise<string | null> => { const setRemotePort = (port: number): Promise<null | string> => {
const result = ipcRenderer.invoke('remote-port', port); const result = ipcRenderer.invoke('remote-port', port);
return result; return result;
}; };
@ -56,7 +57,7 @@ const updateSetting = (
port: number, port: number,
username: string, username: string,
password: string, password: string,
): Promise<string | null> => { ): Promise<null | string> => {
return ipcRenderer.invoke('remote-settings', enabled, port, username, password); return ipcRenderer.invoke('remote-settings', enabled, port, username, password);
}; };

12
src/main/preload/utils.ts → src/preload/utils.ts
View file

@ -1,6 +1,6 @@
import { IpcRendererEvent, ipcRenderer } from 'electron'; import { ipcRenderer, IpcRendererEvent } from 'electron';
import { isMacOS, isWindows, isLinux } from '../utils';
import { PlayerState } from '/@/renderer/store'; import { isLinux, isMacOS, isWindows } from '../main/utils';
const saveQueue = (data: Record<string, any>) => { const saveQueue = (data: Record<string, any>) => {
ipcRenderer.send('player-save-queue', data); ipcRenderer.send('player-save-queue', data);
@ -18,7 +18,7 @@ const onSaveQueue = (cb: (event: IpcRendererEvent) => void) => {
ipcRenderer.on('renderer-save-queue', cb); ipcRenderer.on('renderer-save-queue', cb);
}; };
const onRestoreQueue = (cb: (event: IpcRendererEvent, data: Partial<PlayerState>) => void) => { const onRestoreQueue = (cb: (event: IpcRendererEvent, data: Partial<any>) => void) => {
ipcRenderer.on('renderer-restore-queue', cb); ipcRenderer.on('renderer-restore-queue', cb);
}; };
@ -29,7 +29,7 @@ const playerErrorListener = (cb: (event: IpcRendererEvent, data: { code: number
const mainMessageListener = ( const mainMessageListener = (
cb: ( cb: (
event: IpcRendererEvent, event: IpcRendererEvent,
data: { message: string; type: 'success' | 'error' | 'warning' | 'info' }, data: { message: string; type: 'error' | 'info' | 'success' | 'warning' },
) => void, ) => void,
) => { ) => {
ipcRenderer.on('toast-from-main', cb); ipcRenderer.on('toast-from-main', cb);
@ -40,7 +40,7 @@ const logger = (
event: IpcRendererEvent, event: IpcRendererEvent,
data: { data: {
message: string; message: string;
type: 'debug' | 'verbose' | 'error' | 'warning' | 'info'; type: 'debug' | 'error' | 'info' | 'verbose' | 'warning';
}, },
) => void, ) => void,
) => { ) => {

10
src/remote/app.tsx
View file

@ -1,8 +1,10 @@
import { useEffect } from 'react';
import { MantineProvider } from '@mantine/core'; import { MantineProvider } from '@mantine/core';
import { useEffect } from 'react';
import './styles/global.scss'; import './styles/global.scss';
import { useIsDark, useReconnect } from '/@/remote/store';
import { Shell } from '/@/remote/components/shell'; import { Shell } from '/@/remote/components/shell';
import { useIsDark, useReconnect } from '/@/remote/store';
export const App = () => { export const App = () => {
const isDark = useIsDark(); const isDark = useIsDark();
@ -14,8 +16,6 @@ export const App = () => {
return ( return (
<MantineProvider <MantineProvider
withGlobalStyles
withNormalizeCSS
theme={{ theme={{
colorScheme: isDark ? 'dark' : 'light', colorScheme: isDark ? 'dark' : 'light',
components: { components: {
@ -77,6 +77,8 @@ export const App = () => {
xs: '0rem', xs: '0rem',
}, },
}} }}
withGlobalStyles
withNormalizeCSS
> >
<Shell /> <Shell />
</MantineProvider> </MantineProvider>

3
src/remote/components/buttons/image-button.tsx
View file

@ -1,4 +1,5 @@
import { CiImageOff, CiImageOn } from 'react-icons/ci'; import { CiImageOff, CiImageOn } from 'react-icons/ci';
import { RemoteButton } from '/@/remote/components/buttons/remote-button'; import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import { useShowImage, useToggleShowImage } from '/@/remote/store'; import { useShowImage, useToggleShowImage } from '/@/remote/store';
@ -9,10 +10,10 @@ export const ImageButton = () => {
return ( return (
<RemoteButton <RemoteButton
mr={5} mr={5}
onClick={() => toggleImage()}
size="xl" size="xl"
tooltip={showImage ? 'Hide Image' : 'Show Image'} tooltip={showImage ? 'Hide Image' : 'Show Image'}
variant="default" variant="default"
onClick={() => toggleImage()}
> >
{showImage ? <CiImageOff size={30} /> : <CiImageOn size={30} />} {showImage ? <CiImageOff size={30} /> : <CiImageOn size={30} />}
</RemoteButton> </RemoteButton>

5
src/remote/components/buttons/reconnect-button.tsx
View file

@ -1,6 +1,7 @@
import { RiRestartLine } from 'react-icons/ri';
import { RemoteButton } from '/@/remote/components/buttons/remote-button'; import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import { useConnected, useReconnect } from '/@/remote/store'; import { useConnected, useReconnect } from '/@/remote/store';
import { RiRestartLine } from 'react-icons/ri';
export const ReconnectButton = () => { export const ReconnectButton = () => {
const connected = useConnected(); const connected = useConnected();
@ -10,10 +11,10 @@ export const ReconnectButton = () => {
<RemoteButton <RemoteButton
$active={!connected} $active={!connected}
mr={5} mr={5}
onClick={() => reconnect()}
size="xl" size="xl"
tooltip={connected ? 'Reconnect' : 'Not connected. Reconnect.'} tooltip={connected ? 'Reconnect' : 'Not connected. Reconnect.'}
variant="default" variant="default"
onClick={() => reconnect()}
> >
<RiRestartLine size={30} /> <RiRestartLine size={30} />
</RemoteButton> </RemoteButton>

25
src/remote/components/buttons/remote-button.tsx
View file

@ -1,8 +1,11 @@
import { MouseEvent, ReactNode, Ref, forwardRef } from 'react'; import { Button, type ButtonProps as MantineButtonProps, Tooltip } from '@mantine/core';
import { Button, type ButtonProps as MantineButtonProps } from '@mantine/core'; import { forwardRef, MouseEvent, ReactNode, Ref } from 'react';
import { Tooltip } from '/@/renderer/components/tooltip';
import styled from 'styled-components'; import styled from 'styled-components';
export interface ButtonProps extends StyledButtonProps {
tooltip: string;
}
interface StyledButtonProps extends MantineButtonProps { interface StyledButtonProps extends MantineButtonProps {
$active?: boolean; $active?: boolean;
children: ReactNode; children: ReactNode;
@ -11,10 +14,6 @@ interface StyledButtonProps extends MantineButtonProps {
ref: Ref<HTMLButtonElement>; ref: Ref<HTMLButtonElement>;
} }
export interface ButtonProps extends StyledButtonProps {
tooltip: string;
}
const StyledButton = styled(Button)<StyledButtonProps>` const StyledButton = styled(Button)<StyledButtonProps>`
svg { svg {
display: flex; display: flex;
@ -35,12 +34,12 @@ const StyledButton = styled(Button)<StyledButtonProps>`
} }
`; `;
export const RemoteButton = forwardRef<HTMLButtonElement, ButtonProps>( export const RemoteButton = forwardRef<HTMLButtonElement, any>(
({ children, tooltip, ...props }: ButtonProps, ref) => { ({ children, tooltip, ...props }: any, ref) => {
return ( return (
<Tooltip <Tooltip
withinPortal
label={tooltip} label={tooltip}
withinPortal
> >
<StyledButton <StyledButton
{...props} {...props}
@ -52,9 +51,3 @@ export const RemoteButton = forwardRef<HTMLButtonElement, ButtonProps>(
); );
}, },
); );
RemoteButton.defaultProps = {
$active: false,
onClick: undefined,
onMouseDown: undefined,
};

11
src/remote/components/buttons/theme-button.tsx
View file

@ -1,8 +1,9 @@
import { useIsDark, useToggleDark } from '/@/remote/store';
import { RiMoonLine, RiSunLine } from 'react-icons/ri';
import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import { AppTheme } from '/@/renderer/themes/types';
import { useEffect } from 'react'; import { useEffect } from 'react';
import { RiMoonLine, RiSunLine } from 'react-icons/ri';
import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import { useIsDark, useToggleDark } from '/@/remote/store';
import { AppTheme } from '/@/shared/types/domain-types';
export const ThemeButton = () => { export const ThemeButton = () => {
const isDark = useIsDark(); const isDark = useIsDark();
@ -16,10 +17,10 @@ export const ThemeButton = () => {
return ( return (
<RemoteButton <RemoteButton
mr={5} mr={5}
onClick={() => toggleDark()}
size="xl" size="xl"
tooltip="Toggle Theme" tooltip="Toggle Theme"
variant="default" variant="default"
onClick={() => toggleDark()}
> >
{isDark ? <RiSunLine size={30} /> : <RiMoonLine size={30} />} {isDark ? <RiSunLine size={30} /> : <RiMoonLine size={30} />}
</RemoteButton> </RemoteButton>

39
src/remote/components/remote-container.tsx
View file

@ -1,9 +1,7 @@
import { useCallback } from 'react'; import { Group, Image, Rating, Text, Title, Tooltip } from '@mantine/core';
import { Group, Image, Text, Title } from '@mantine/core';
import { useInfo, useSend, useShowImage } from '/@/remote/store';
import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import formatDuration from 'format-duration'; import formatDuration from 'format-duration';
import debounce from 'lodash/debounce'; import debounce from 'lodash/debounce';
import { useCallback } from 'react';
import { import {
RiHeartLine, RiHeartLine,
RiPauseFill, RiPauseFill,
@ -15,10 +13,11 @@ import {
RiSkipForwardFill, RiSkipForwardFill,
RiVolumeUpFill, RiVolumeUpFill,
} from 'react-icons/ri'; } from 'react-icons/ri';
import { PlayerRepeat, PlayerStatus } from '/@/renderer/types';
import { RemoteButton } from '/@/remote/components/buttons/remote-button';
import { WrapperSlider } from '/@/remote/components/wrapped-slider'; import { WrapperSlider } from '/@/remote/components/wrapped-slider';
import { Tooltip } from '/@/renderer/components/tooltip'; import { useInfo, useSend, useShowImage } from '/@/remote/store';
import { Rating } from '/@/renderer/components/rating'; import { PlayerRepeat, PlayerStatus } from '/@/shared/types/types';
export const RemoteContainer = () => { export const RemoteContainer = () => {
const { position, repeat, shuffle, song, status, volume } = useInfo(); const { position, repeat, shuffle, song, status, volume } = useInfo();
@ -62,16 +61,14 @@ export const RemoteContainer = () => {
> >
<RemoteButton <RemoteButton
disabled={!id} disabled={!id}
onClick={() => send({ event: 'previous' })}
tooltip="Previous track" tooltip="Previous track"
variant="default" variant="default"
onClick={() => send({ event: 'previous' })}
> >
<RiSkipBackFill size={25} /> <RiSkipBackFill size={25} />
</RemoteButton> </RemoteButton>
<RemoteButton <RemoteButton
disabled={!id} disabled={!id}
tooltip={id && status === PlayerStatus.PLAYING ? 'Pause' : 'Play'}
variant="default"
onClick={() => { onClick={() => {
if (status === PlayerStatus.PLAYING) { if (status === PlayerStatus.PLAYING) {
send({ event: 'pause' }); send({ event: 'pause' });
@ -79,6 +76,8 @@ export const RemoteContainer = () => {
send({ event: 'play' }); send({ event: 'play' });
} }
}} }}
tooltip={id && status === PlayerStatus.PLAYING ? 'Pause' : 'Play'}
variant="default"
> >
{id && status === PlayerStatus.PLAYING ? ( {id && status === PlayerStatus.PLAYING ? (
<RiPauseFill size={25} /> <RiPauseFill size={25} />
@ -88,9 +87,9 @@ export const RemoteContainer = () => {
</RemoteButton> </RemoteButton>
<RemoteButton <RemoteButton
disabled={!id} disabled={!id}
onClick={() => send({ event: 'next' })}
tooltip="Next track" tooltip="Next track"
variant="default" variant="default"
onClick={() => send({ event: 'next' })}
> >
<RiSkipForwardFill size={25} /> <RiSkipForwardFill size={25} />
</RemoteButton> </RemoteButton>
@ -101,14 +100,15 @@ export const RemoteContainer = () => {
> >
<RemoteButton <RemoteButton
$active={shuffle || false} $active={shuffle || false}
onClick={() => send({ event: 'shuffle' })}
tooltip={shuffle ? 'Shuffle tracks' : 'Shuffle disabled'} tooltip={shuffle ? 'Shuffle tracks' : 'Shuffle disabled'}
variant="default" variant="default"
onClick={() => send({ event: 'shuffle' })}
> >
<RiShuffleFill size={25} /> <RiShuffleFill size={25} />
</RemoteButton> </RemoteButton>
<RemoteButton <RemoteButton
$active={repeat !== undefined && repeat !== PlayerRepeat.NONE} $active={repeat !== undefined && repeat !== PlayerRepeat.NONE}
onClick={() => send({ event: 'repeat' })}
tooltip={`Repeat ${ tooltip={`Repeat ${
repeat === PlayerRepeat.ONE repeat === PlayerRepeat.ONE
? 'One' ? 'One'
@ -117,7 +117,6 @@ export const RemoteContainer = () => {
: 'none' : 'none'
}`} }`}
variant="default" variant="default"
onClick={() => send({ event: 'repeat' })}
> >
{repeat === undefined || repeat === PlayerRepeat.ONE ? ( {repeat === undefined || repeat === PlayerRepeat.ONE ? (
<RiRepeatOneLine size={25} /> <RiRepeatOneLine size={25} />
@ -128,13 +127,13 @@ export const RemoteContainer = () => {
<RemoteButton <RemoteButton
$active={song?.userFavorite} $active={song?.userFavorite}
disabled={!id} disabled={!id}
tooltip={song?.userFavorite ? 'Unfavorite' : 'Favorite'}
variant="default"
onClick={() => { onClick={() => {
if (!id) return; if (!id) return;
send({ event: 'favorite', favorite: !song.userFavorite, id }); send({ event: 'favorite', favorite: !song.userFavorite, id });
}} }}
tooltip={song?.userFavorite ? 'Unfavorite' : 'Favorite'}
variant="default"
> >
<RiHeartLine size={25} /> <RiHeartLine size={25} />
</RemoteButton> </RemoteButton>
@ -145,10 +144,10 @@ export const RemoteContainer = () => {
openDelay={1000} openDelay={1000}
> >
<Rating <Rating
sx={{ margin: 'auto' }}
value={song.userRating ?? 0}
onChange={debouncedSetRating} onChange={debouncedSetRating}
onDoubleClick={() => debouncedSetRating(0)} onDoubleClick={() => debouncedSetRating(0)}
sx={{ margin: 'auto' }}
value={song.userRating ?? 0}
/> />
</Tooltip> </Tooltip>
</div> </div>
@ -159,14 +158,15 @@ export const RemoteContainer = () => {
label={(value) => formatDuration(value * 1e3)} label={(value) => formatDuration(value * 1e3)}
leftLabel={formatDuration(position * 1e3)} leftLabel={formatDuration(position * 1e3)}
max={song.duration / 1e3} max={song.duration / 1e3}
onChangeEnd={(e) => send({ event: 'position', position: e })}
rightLabel={formatDuration(song.duration)} rightLabel={formatDuration(song.duration)}
value={position} value={position}
onChangeEnd={(e) => send({ event: 'position', position: e })}
/> />
)} )}
<WrapperSlider <WrapperSlider
leftLabel={<RiVolumeUpFill size={20} />} leftLabel={<RiVolumeUpFill size={20} />}
max={100} max={100}
onChangeEnd={(e) => send({ event: 'volume', volume: e })}
rightLabel={ rightLabel={
<Text <Text
size="xs" size="xs"
@ -176,12 +176,11 @@ export const RemoteContainer = () => {
</Text> </Text>
} }
value={volume ?? 0} value={volume ?? 0}
onChangeEnd={(e) => send({ event: 'volume', volume: e })}
/> />
{showImage && ( {showImage && (
<Image <Image
src={song?.imageUrl?.replaceAll(/&(size|width|height=\d+)/g, '')}
onError={() => send({ event: 'proxy' })} onError={() => send({ event: 'proxy' })}
src={song?.imageUrl?.replaceAll(/&(size|width|height=\d+)/g, '')}
/> />
)} )}
</> </>

5
src/remote/components/shell.tsx
View file

@ -9,10 +9,11 @@ import {
Skeleton, Skeleton,
Title, Title,
} from '@mantine/core'; } from '@mantine/core';
import { ThemeButton } from '/@/remote/components/buttons/theme-button';
import { ImageButton } from '/@/remote/components/buttons/image-button'; import { ImageButton } from '/@/remote/components/buttons/image-button';
import { RemoteContainer } from '/@/remote/components/remote-container';
import { ReconnectButton } from '/@/remote/components/buttons/reconnect-button'; import { ReconnectButton } from '/@/remote/components/buttons/reconnect-button';
import { ThemeButton } from '/@/remote/components/buttons/theme-button';
import { RemoteContainer } from '/@/remote/components/remote-container';
import { useConnected } from '/@/remote/store'; import { useConnected } from '/@/remote/store';
export const Shell = () => { export const Shell = () => {

59
src/remote/components/wrapped-slider.tsx
View file

@ -1,7 +1,6 @@
import { useState, ReactNode } from 'react'; import { rem, Slider, SliderProps } from '@mantine/core';
import { SliderProps } from '@mantine/core'; import { ReactNode, useState } from 'react';
import styled from 'styled-components'; import styled from 'styled-components';
import { PlayerbarSlider } from '/@/renderer/features/player/components/playerbar-slider';
const SliderContainer = styled.div` const SliderContainer = styled.div`
display: flex; display: flex;
@ -25,6 +24,54 @@ const SliderWrapper = styled.div`
height: 100%; height: 100%;
`; `;
const PlayerbarSlider = ({ ...props }: SliderProps) => {
return (
<Slider
styles={{
bar: {
backgroundColor: 'var(--playerbar-slider-track-progress-bg)',
transition: 'background-color 0.2s ease',
},
label: {
backgroundColor: 'var(--tooltip-bg)',
color: 'var(--tooltip-fg)',
fontSize: '1.1rem',
fontWeight: 600,
padding: '0 1rem',
},
root: {
'&:hover': {
'& .mantine-Slider-bar': {
backgroundColor: 'var(--primary-color)',
},
'& .mantine-Slider-thumb': {
opacity: 1,
},
},
},
thumb: {
backgroundColor: 'var(--slider-thumb-bg)',
borderColor: 'var(--primary-color)',
borderWidth: rem(1),
height: '1rem',
opacity: 0,
width: '1rem',
},
track: {
'&::before': {
backgroundColor: 'var(--playerbar-slider-track-bg)',
right: 'calc(0.1rem * -1)',
},
},
}}
{...props}
onClick={(e) => {
e?.stopPropagation();
}}
/>
);
};
export interface WrappedProps extends Omit<SliderProps, 'onChangeEnd'> { export interface WrappedProps extends Omit<SliderProps, 'onChangeEnd'> {
leftLabel?: ReactNode; leftLabel?: ReactNode;
onChangeEnd: (value: number) => void; onChangeEnd: (value: number) => void;
@ -43,9 +90,6 @@ export const WrapperSlider = ({ leftLabel, rightLabel, value, ...props }: Wrappe
<PlayerbarSlider <PlayerbarSlider
{...props} {...props}
min={0} min={0}
size={6}
value={!isSeeking ? (value ?? 0) : seek}
w="100%"
onChange={(e) => { onChange={(e) => {
setIsSeeking(true); setIsSeeking(true);
setSeek(e); setSeek(e);
@ -54,6 +98,9 @@ export const WrapperSlider = ({ leftLabel, rightLabel, value, ...props }: Wrappe
props.onChangeEnd(e); props.onChangeEnd(e);
setIsSeeking(false); setIsSeeking(false);
}} }}
size={6}
value={!isSeeking ? (value ?? 0) : seek}
w="100%"
/> />
</SliderWrapper> </SliderWrapper>
{rightLabel && <SliderValueWrapper $position="right">{rightLabel}</SliderValueWrapper>} {rightLabel && <SliderValueWrapper $position="right">{rightLabel}</SliderValueWrapper>}

23
src/remote/index.ejs
View file

@ -1,23 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="Content-Security-Policy" />
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Feishin Remote</title>
<link rel="manifest" href="manifest.json">
<script>
if ('serviceWorker' in navigator) {
const version = encodeURIComponent("<%= version %>");
const prod = encodeURIComponent("<%= prod %>");
navigator.serviceWorker.register(`/worker.js?version=${version}&prod=${prod}`);
}
</script>
</head>
<body>
<div id="root"></div>
</body>
</html>

27
src/remote/index.html Normal file
View file

@ -0,0 +1,27 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta http-equiv="Content-Security-Policy" />
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Feishin Remote</title>
<link rel="manifest" href="manifest.json">
<script>
if ('serviceWorker' in navigator) {
const version = encodeURIComponent("<%= version %>");
const prod = encodeURIComponent("<%= prod %>");
navigator.serviceWorker.register(`/worker.js?version=${version}&prod=${prod}`);
}
</script>
<link rel="icon" href="./favicon.ico">
<script defer="defer" src="./remote.js"></script>
<script defer="defer" src="./worker.js"></script>
<link rel="stylesheet" href="./remote.css">
</head>
<body>
<div id="root"></div>
</body>
</html>

1
src/remote/index.tsx
View file

@ -1,5 +1,6 @@
import { Notifications } from '@mantine/notifications'; import { Notifications } from '@mantine/notifications';
import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client';
import { App } from '/@/remote/app'; import { App } from '/@/remote/app';
const container = document.getElementById('root')! as HTMLElement; const container = document.getElementById('root')! as HTMLElement;

3
src/remote/service-worker.ts
View file

@ -1,10 +1,9 @@
/// <reference lib="WebWorker" /> /// <reference lib="WebWorker" />
export type {}; export type {};
// eslint-disable-next-line no-undef
declare const self: ServiceWorkerGlobalScope; declare const self: ServiceWorkerGlobalScope;
// eslint-disable-next-line no-restricted-globals
const url = new URL(location.toString()); const url = new URL(location.toString());
const version = url.searchParams.get('version'); const version = url.searchParams.get('version');
const prod = url.searchParams.get('prod') === 'true'; const prod = url.searchParams.get('prod') === 'true';

30
src/remote/store/index.ts
View file

@ -1,13 +1,20 @@
import { hideNotification, showNotification } from '@mantine/notifications';
import type { NotificationProps as MantineNotificationProps } from '@mantine/notifications'; import type { NotificationProps as MantineNotificationProps } from '@mantine/notifications';
import { hideNotification, showNotification } from '@mantine/notifications';
import merge from 'lodash/merge'; import merge from 'lodash/merge';
import { create } from 'zustand'; import { create } from 'zustand';
import { devtools, persist } from 'zustand/middleware'; import { devtools, persist } from 'zustand/middleware';
import { immer } from 'zustand/middleware/immer'; import { immer } from 'zustand/middleware/immer';
import type { ClientEvent, ServerEvent, SongUpdateSocket } from '/@/remote/types';
interface StatefulWebSocket extends WebSocket { import { ClientEvent, ServerEvent, SongUpdateSocket } from '/@/shared/types/remote-types';
natural: boolean;
export interface SettingsSlice extends SettingsState {
actions: {
reconnect: () => void;
send: (data: ClientEvent) => void;
toggleIsDark: () => void;
toggleShowImage: () => void;
};
} }
interface SettingsState { interface SettingsState {
@ -18,13 +25,8 @@ interface SettingsState {
socket?: StatefulWebSocket; socket?: StatefulWebSocket;
} }
export interface SettingsSlice extends SettingsState { interface StatefulWebSocket extends WebSocket {
actions: { natural: boolean;
reconnect: () => void;
send: (data: ClientEvent) => void;
toggleIsDark: () => void;
toggleShowImage: () => void;
};
} }
const initialState: SettingsState = { const initialState: SettingsState = {
@ -106,19 +108,18 @@ export const useRemoteStore = create<SettingsSlice>()(
const credentials = await fetch('/credentials'); const credentials = await fetch('/credentials');
authHeader = await credentials.text(); authHeader = await credentials.text();
} catch (error) { } catch (error) {
console.error('Failed to get credentials'); console.error('Failed to get credentials', error);
} }
set((state) => { set((state) => {
const socket = new WebSocket( const socket = new WebSocket(
// eslint-disable-next-line no-restricted-globals
location.href.replace('http', 'ws'), location.href.replace('http', 'ws'),
) as StatefulWebSocket; ) as StatefulWebSocket;
socket.natural = false; socket.natural = false;
socket.addEventListener('message', (message) => { socket.addEventListener('message', (message) => {
const { event, data } = JSON.parse(message.data) as ServerEvent; const { data, event } = JSON.parse(message.data) as ServerEvent;
switch (event) { switch (event) {
case 'error': { case 'error': {
@ -207,7 +208,6 @@ export const useRemoteStore = create<SettingsSlice>()(
socket.addEventListener('close', (reason) => { socket.addEventListener('close', (reason) => {
if (reason.code === 4002 || reason.code === 4003) { if (reason.code === 4002 || reason.code === 4003) {
// eslint-disable-next-line no-restricted-globals
location.reload(); location.reload();
} else if (reason.code === 4000) { } else if (reason.code === 4000) {
toast.warn({ toast.warn({

14
src/renderer/api/controller.ts
View file

@ -1,10 +1,14 @@
import { useAuthStore } from '/@/renderer/store'; import i18n from '/@/i18n/i18n';
import { toast } from '/@/renderer/components/toast/index'; import { JellyfinController } from '/@/renderer/api/jellyfin/jellyfin-controller';
import type { ServerType, ControllerEndpoint, AuthenticationResponse } from '/@/renderer/api/types';
import { NavidromeController } from '/@/renderer/api/navidrome/navidrome-controller'; import { NavidromeController } from '/@/renderer/api/navidrome/navidrome-controller';
import { SubsonicController } from '/@/renderer/api/subsonic/subsonic-controller'; import { SubsonicController } from '/@/renderer/api/subsonic/subsonic-controller';
import { JellyfinController } from '/@/renderer/api/jellyfin/jellyfin-controller'; import { toast } from '/@/renderer/components/toast/index';
import i18n from '/@/i18n/i18n'; import { useAuthStore } from '/@/renderer/store';
import {
AuthenticationResponse,
ControllerEndpoint,
ServerType,
} from '/@/shared/types/domain-types';
type ApiController = { type ApiController = {
jellyfin: ControllerEndpoint; jellyfin: ControllerEndpoint;

Some files were not shown because too many files have changed in this diff Show more