Cleanup

Add preliminary prisma support
Initial commit
2026-05-08 04:50:12 +02:00 · 2022-10-06 21:28:57 -07:00 · 2022-10-06 21:17:40 -07:00 · 2022-10-06 15:52:01 -07:00
629 changed files with 19968 additions and 118546 deletions
@@ -1,3 +0,0 @@
 node_modules
 Dockerfile
 docker-compose.*
@@ -2,7 +2,7 @@ root = true
 [*]
 indent_style = space
-indent_size = 4
+indent_size = 2
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
@@ -1,7 +0,0 @@
 {
  "rules": {
    "no-console": "off",
    "global-require": "off",
    "import/no-dynamic-require": "off"
  }
 }
@@ -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;
@@ -1,3 +0,0 @@
 /* eslint import/no-unresolved: off, import/no-self-import: off */
 module.exports = require('./webpack.config.renderer.dev').default;
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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 +0,0 @@
 export default 'test-file-stub';
@@ -1,8 +0,0 @@
 {
  "rules": {
    "no-console": "off",
    "global-require": "off",
    "import/no-dynamic-require": "off",
    "import/no-extraneous-dependencies": "off"
  }
 }
@@ -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"',
    ),
  );
 }
@@ -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');
  }
 }
@@ -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);
  }
 }
@@ -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);
  }
 });
@@ -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);
  }
 });
@@ -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'));
 }
@@ -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',
  });
 }
@@ -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');
 }
@@ -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,
  });
 };
@@ -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
@@ -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'),
            },
        },
    },
 };
@@ -0,0 +1,82 @@
 {
  "env": {
    "browser": true,
    "es2021": true
  },
  "ignorePatterns": [
    "node_modules/*",
    "dist/*",
    "electron/preload/*",
    "vite.config.ts",
    "post-install.js"
  ],
  "extends": [
    "plugin:react/recommended",
    "plugin:react-hooks/recommended",
    "eslint:recommended",
    "plugin:@typescript-eslint/eslint-recommended",
    "plugin:@typescript-eslint/recommended",
    "plugin:typescript-sort-keys/recommended",
    "prettier"
  ],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaFeatures": {
      "jsx": true
    },
    "ecmaVersion": "latest",
    "sourceType": "module"
  },
  "plugins": [
    "react",
    "@typescript-eslint",
    "import",
    "sort-keys-fix",
    "promise"
  ],
  "rules": {
    "react-hooks/exhaustive-deps": [
      "warn",
      { "enableDangerousAutofixThisMayCauseInfiniteLoops": true }
    ],
    "react/jsx-sort-props": [
      "error",
      {
        "callbacksLast": true,
        "ignoreCase": false,
        "noSortAlphabetically": false,
        "reservedFirst": true,
        "shorthandFirst": true,
        "shorthandLast": false
      }
    ],
    "import/order": [
      "error",
      {
        "groups": ["builtin", "external", "internal", ["parent", "sibling"]],
        "pathGroups": [
          {
            "pattern": "react",
            "group": "external",
            "position": "before"
          }
        ],
        "pathGroupsExcludedImportTypes": ["react"],
        "newlines-between": "never",
        "alphabetize": {
          "order": "asc",
          "caseInsensitive": true
        }
      }
    ],
    "sort-keys-fix/sort-keys-fix": "warn",
    "@typescript-eslint/no-explicit-any": "off",
    "consistent-return": "off",
    "object-curly-newline": "off",
    "indent": "off",
    "no-tabs": "off",
    "react/jsx-indent": "off",
    "react/jsx-indent-props": "off",
    "react/react-in-jsx-scope": "off"
  }
 }
@@ -1,12 +0,0 @@
 *       text    eol=lf
 *.exe   binary
 *.png   binary
 *.jpg   binary
 *.jpeg  binary
 *.ico   binary
 *.icns  binary
 *.eot   binary
 *.otf   binary
 *.ttf   binary
 *.woff  binary
 *.woff2 binary
@@ -1,3 +0,0 @@
 # These are supported funding model platforms
 ko_fi: jeffvli
@@ -1,63 +0,0 @@
 name: Bug report
 description: You're having technical issues. 🐞
 labels: ['bug']
 body:
    - type: textarea
      attributes:
          label: Expected Behavior
          description: What should have happened?
      validations:
          required: true
    - type: textarea
      attributes:
          label: Current Behavior
          description: What went wrong? Add screenshots to help explain your problem. (Open the browser dev tools in the menu or using CTRL + SHIFT + I)
      validations:
          required: true
    - type: textarea
      attributes:
          label: Steps to Reproduce
          placeholder: |
              <!-- Add relevant code and/or a live example -->
              <!-- Add stack traces -->
              1.
              2.
              3.
              4.
      validations:
          required: true
    - type: textarea
      attributes:
          label: Possible Solution
          description: Suggest a reason for the bug or how to fix it.
      validations:
          required: false
    - type: textarea
      attributes:
          label: Context
          description: How has this issue affected you? What are you trying to accomplish?
      validations:
          required: false
    - type: input
      attributes:
          label: Application version
          placeholder: (e.g. v0.1.0)
      validations:
          required: true
    - type: input
      attributes:
          label: Operating System and version
          placeholder: (e.g. Windows 11 desktop, Webapp in Firefox)
      validations:
          required: true
    - type: input
      attributes:
          label: Server and Version
          placeholder: (e.g. Navidrome v0.48.0)
      validations:
          required: true
    - type: input
      attributes:
          label: Node Version (if developing locally)
      validations:
          required: false
@@ -1,5 +0,0 @@
 blank_issues_enabled: true
 contact_links:
    - name: Question
      url: https://github.com/jeffvli/feishin/discussions
      about: Please ask and answer questions here.
@@ -1,20 +0,0 @@
 name: Feature request - NOT ACCEPTING NEW FEATURE REQUESTS
 description: Feature requests are currently closed. The application is actively being rewritten https://github.com/audioling/audioling.
 labels: ['enhancement']
 body:
    - type: textarea
      attributes:
          label: What do you want to be added?
      validations:
          required: true
    - type: textarea
      attributes:
          label: Additional context
      validations:
          required: false
    - type: checkboxes
      attributes:
          label: Is this a server-specific feature? (e.g. Jellyfin only)
          options:
              - label: 'Yes'
                required: false
@@ -1,6 +0,0 @@
 requiredHeaders:
    - Prerequisites
    - Expected Behavior
    - Current Behavior
    - Possible Solution
    - Your Environment
@@ -1,17 +0,0 @@
 # Number of days of inactivity before an issue becomes stale
 daysUntilStale: 60
 # Number of days of inactivity before a stale issue is closed
 daysUntilClose: 7
 # Issues with these labels will never be considered stale
 exemptLabels:
    - discussion
    - security
 # Label to use when marking an issue as stale
 staleLabel: wontfix
 # Comment to post when marking an issue as stale. Set to `false` to disable
 markComment: >
    This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.
 # Comment to post when closing a stale issue. Set to `false` to disable
 closeComment: false
@@ -1,54 +0,0 @@
 # Referenced from: https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#introduction
 name: Publish Docker to GHCR
 permissions: write-all
 on:
    push:
        tags:
            - 'v*.*.*'
 env:
    REGISTRY: ghcr.io
    IMAGE_NAME: ${{ github.repository }}
 jobs:
    build-and-push-image:
        runs-on: ubuntu-latest
        permissions:
            contents: read
            packages: write
        steps:
            - name: Checkout repository
              uses: actions/checkout@v4
            - name: Log in to the Container registry
              uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
              with:
                  registry: ${{ env.REGISTRY }}
                  username: ${{ github.actor }}
                  password: ${{ secrets.GITHUB_TOKEN }}
            - name: Extract metadata (tags, labels) for Docker
              id: meta
              uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
              with:
                  images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
                  tags: |
                      type=ref,event=branch
                      type=ref,event=pr
                      type=semver,pattern={{version}}
                      type=semver,pattern={{major}}.{{minor}}
                      type=semver,pattern={{major}}
            - name: Set up QEMU
              uses: docker/setup-qemu-action@v3
            - name: Setup Docker buildx
              uses: docker/setup-buildx-action@v3
            - name: Build and push Docker image
              uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
              with:
                  context: .
                  push: true
                  tags: ${{ steps.meta.outputs.tags }}
                  labels: ${{ steps.meta.outputs.labels }}
                  platforms: |
                    linux/amd64
                    linux/arm/v7
                    linux/arm64/v8
@@ -1,46 +0,0 @@
 # Referenced from: https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#introduction
 name: Publish Docker to GHCR (Manual)
 on: workflow_dispatch
 env:
    REGISTRY: ghcr.io
    IMAGE_NAME: ${{ github.repository }}
 jobs:
    build-and-push-image:
        runs-on: ubuntu-latest
        permissions:
            contents: read
            packages: write
        steps:
            - name: Checkout repository
              uses: actions/checkout@v4
            - name: Log in to the Container registry
              uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
              with:
                  registry: ${{ env.REGISTRY }}
                  username: ${{ github.actor }}
                  password: ${{ secrets.GITHUB_TOKEN }}
            - name: Extract metadata (tags, labels) for Docker
              id: meta
              uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
              with:
                  images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
                  tags: |
                      type=raw,value=latest,enable={{is_default_branch}}
            - name: Set up QEMU
              uses: docker/setup-qemu-action@v3
            - name: Setup Docker buildx
              uses: docker/setup-buildx-action@v3
            - name: Build and push Docker image
              uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
              with:
                  context: .
                  push: true
                  tags: ${{ steps.meta.outputs.tags }}
                  labels: ${{ steps.meta.outputs.labels }}
                  platforms: |
                    linux/amd64
                    linux/arm/v7
                    linux/arm64/v8
@@ -1,53 +0,0 @@
 name: Publish Linux (Manual)
 on: workflow_dispatch
 jobs:
    publish:
        runs-on: ${{ matrix.os }}
        strategy:
            matrix:
                os: [ubuntu-latest]
        steps:
            - name: Checkout git repo
              uses: actions/checkout@v1
            - name: Install Node and NPM
              uses: actions/setup-node@v1
              with:
                  node-version: 18
                  cache: npm
            - name: Install dependencies
              run: |
                  npm install --legacy-peer-deps
            - name: Publish releases
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              uses: nick-invision/retry@v2.8.2
              with:
                  timeout_minutes: 30
                  max_attempts: 3
                  retry_on: error
                  command: |
                      npm run postinstall
                      npm run build
                      npm exec electron-builder -- --publish always --linux
                  on_retry_command: npm cache clean --force
            - name: Publish releases (arm64)
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              uses: nick-invision/retry@v2.8.2
              with:
                  timeout_minutes: 30
                  max_attempts: 3
                  retry_on: error
                  command: |
                      npm run postinstall
                      npm run build
                      npm exec electron-builder -- --publish always --arm64
                  on_retry_command: npm cache clean --force
@@ -1,39 +0,0 @@
 name: Publish macOS (Manual)
 on: workflow_dispatch
 jobs:
    publish:
        runs-on: ${{ matrix.os }}
        strategy:
            matrix:
                os: [macos-latest]
        steps:
            - name: Checkout git repo
              uses: actions/checkout@v1
            - name: Install Node and NPM
              uses: actions/setup-node@v1
              with:
                  node-version: 18
                  cache: npm
            - name: Install dependencies
              run: |
                  npm install --legacy-peer-deps
            - name: Publish releases
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              uses: nick-invision/retry@v2.8.2
              with:
                  timeout_minutes: 30
                  max_attempts: 3
                  retry_on: error
                  command: |
                      npm run postinstall
                      npm run build
                      npm exec electron-builder -- --publish always --mac
                  on_retry_command: npm cache clean --force
@@ -1,54 +0,0 @@
 name: Comment on pull request
 on:
    workflow_run:
        workflows: ['Publish (PR)']
        types: [completed]
 jobs:
    pr_comment:
        if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
        runs-on: ubuntu-latest
        steps:
            - uses: actions/github-script@v6
              with:
                  # This snippet is public-domain, taken from
                  # https://github.com/oprypin/nightly.link/blob/master/.github/workflows/pr-comment.yml
                  script: |
                      async function upsertComment(owner, repo, issue_number, purpose, body) {
                        const {data: comments} = await github.rest.issues.listComments(
                          {owner, repo, issue_number});
                        const marker = `<!-- bot: ${purpose} -->`;
                        body = marker + "\n" + body;
                        const existing = comments.filter((c) => c.body.includes(marker));
                        if (existing.length > 0) {
                          const last = existing[existing.length - 1];
                          core.info(`Updating comment ${last.id}`);
                          await github.rest.issues.updateComment({
                            owner, repo,
                            body,
                            comment_id: last.id,
                          });
                        } else {
                          core.info(`Creating a comment in issue / PR #${issue_number}`);
                          await github.rest.issues.createComment({issue_number, body, owner, repo});
                        }
                      }
                      const {owner, repo} = context.repo;
                      const run_id = ${{github.event.workflow_run.id}};
                      const pull_requests = ${{ toJSON(github.event.workflow_run.pull_requests) }};
                      if (!pull_requests.length) {
                        return core.error("This workflow doesn't match any pull requests!");
                      }
                      const artifacts = await github.paginate(
                        github.rest.actions.listWorkflowRunArtifacts, {owner, repo, run_id});
                      if (!artifacts.length) {
                        return core.error(`No artifacts found`);
                      }
                      let body = `Download the artifacts for this pull request:\n`;
                      for (const art of artifacts) {
                        body += `\n* [${art.name}.zip](https://nightly.link/${owner}/${repo}/actions/artifacts/${art.id}.zip)`;
                      }
                      core.info("Review thread message body:", body);
                      for (const pr of pull_requests) {
                        await upsertComment(owner, repo, pr.number,
                          "nightly-link", body);
                      }
@@ -1,60 +0,0 @@
 name: Publish (PR)
 on:
    pull_request:
        branches:
            - development
 jobs:
    publish:
        runs-on: ${{ matrix.os }}
        strategy:
            matrix:
                os: [macos-latest]
        steps:
            - name: Checkout git repo
              uses: actions/checkout@v3
            - name: Install Node and NPM
              uses: actions/setup-node@v3
              with:
                  node-version: 18
                  cache: npm
            - name: Install dependencies
              run: |
                  npm install --legacy-peer-deps
            - name: Build releases
              uses: nick-invision/retry@v2.8.2
              with:
                  timeout_minutes: 30
                  max_attempts: 3
                  retry_on: error
                  command: |
                      npm run postinstall
                      npm run build
                      npm run package:pr
                  on_retry_command: npm cache clean --force
            - uses: actions/upload-artifact@v3
              with:
                  name: windows-binaries
                  path: |
                      release/build/*.exe
            - uses: actions/upload-artifact@v3
              with:
                  name: linux-binaries
                  path: |
                      release/build/*.AppImage
                      release/build/*.deb
                      release/build/*.rpm
            - uses: actions/upload-artifact@v3
              with:
                  name: macos-binaries
                  path: |
                      release/build/*.dmg
@@ -1,39 +0,0 @@
 name: Publish Windows (Manual)
 on: workflow_dispatch
 jobs:
    publish:
        runs-on: ${{ matrix.os }}
        strategy:
            matrix:
                os: [windows-latest]
        steps:
            - name: Checkout git repo
              uses: actions/checkout@v1
            - name: Install Node and NPM
              uses: actions/setup-node@v1
              with:
                  node-version: 18
                  cache: npm
            - name: Install dependencies
              run: |
                  npm install --legacy-peer-deps
            - name: Publish releases
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              uses: nick-invision/retry@v2.8.2
              with:
                  timeout_minutes: 30
                  max_attempts: 3
                  retry_on: error
                  command: |
                      npm run postinstall
                      npm run build
                      npm exec electron-builder -- --publish always --win
                  on_retry_command: npm cache clean --force
@@ -1,34 +0,0 @@
 name: Test
 on: [push, pull_request]
 jobs:
    release:
        runs-on: ${{ matrix.os }}
        strategy:
            matrix:
                os: [macos-latest, windows-latest, ubuntu-latest]
        steps:
            - name: Check out Git repository
              uses: actions/checkout@v1
            - name: Install Node.js and NPM
              uses: actions/setup-node@v2
              with:
                  node-version: 16
                  cache: npm
            - name: npm install
              run: |
                  npm install --legacy-peer-deps
            - name: npm test
              env:
                  GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
              run: |
                  npm run lint
                  npm run package
                  npm exec tsc
                  npm test
@@ -1,31 +1,29 @@
 # Logs
 logs
 *.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 pnpm-debug.log*
 lerna-debug.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
 dist
 dist-ssr
 *.local
-# OSX
+# Editor directories and files
 .idea
 .DS_Store
 *.suo
 *.ntvs*
 *.njsproj
 *.sln
 *.sw?
 release/app/dist
 release/build
-.erb/dll
+.vscode/.debug.env
-
+./package-lock.json
-.idea
+pnpm-lock.yaml
-npm-debug.log.*
+yarn.lock
 *.css.d.ts
 *.sass.d.ts
 *.scss.d.ts
 .env*
@@ -1,4 +0,0 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 npx lint-staged
@@ -1,22 +1,12 @@
 {
-    "printWidth": 100,
+  "printWidth": 120,
  "tabWidth": 2,
  "useTabs": false,
  "semi": true,
  "singleQuote": true,
-    "tabWidth": 4,
+  "trailingComma": "es5",
    "useTabs": false,
    "overrides": [
        {
            "files": ["**/*.css", "**/*.scss", "**/*.html"],
            "options": {
                "singleQuote": true
            }
        }
    ],
    "trailingComma": "all",
  "bracketSpacing": true,
  "jsxBracketSameLine": false,
  "arrowParens": "always",
-    "proseWrap": "never",
+  "proseWrap": "preserve"
    "htmlWhitespaceSensitivity": "strict",
    "endOfLine": "lf",
    "singleAttributePerLine": true
 }
@@ -1,17 +0,0 @@
 {
    "customSyntax": "postcss-styled-syntax",
    "extends": [
        "stylelint-config-standard",
        "stylelint-config-styled-components",
        "stylelint-config-recess-order"
    ],
    "rules": {
        "declaration-empty-line-before": null,
        "declaration-block-no-redundant-longhand-properties": null,
        "selector-class-pattern": null,
        "selector-type-case": ["lower", { "ignoreTypes": ["/^\\$\\w+/"] }],
        "selector-type-no-unknown": [true, { "ignoreTypes": ["/-styled-mixin/", "/^\\$\\w+/"] }],
        "declaration-colon-newline-after": null,
        "property-no-vendor-prefix": null
    }
 }
@@ -0,0 +1,24 @@
 import fs from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import { createRequire } from 'module'
 import { spawn } from 'child_process'
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
 const pkg = require('../package.json')
 // write .debug.env
 const envContent = Object.entries(pkg.debug.env).map(([key, val]) => `${key}=${val}`)
 fs.writeFileSync(path.join(__dirname, '.debug.env'), envContent.join('\n'))
 // bootstrap
 spawn(
  // TODO: terminate `npm run dev` when Debug exits.
  process.platform === 'win32' ? 'npm.cmd' : 'npm',
  ['run', 'dev'],
  {
    stdio: 'inherit',
    env: Object.assign(process.env, { VSCODE_DEBUG: 'true' }),
  },
 )
@@ -1,10 +1,10 @@
 {
  // See http://go.microsoft.com/fwlink/?LinkId=827846
  // for the documentation about the extensions.json format
  "recommendations": [
-        "dbaeumer.vscode-eslint",
+    "editorconfig.editorconfig",
-        "EditorConfig.EditorConfig",
+    "mrmlnc.vscode-json5",
-        "stylelint.vscode-stylelint",
+    "rbbit.typescript-hero",
-        "esbenp.prettier-vscode",
+    "syler.sass-indented",
        "clinyong.vscode-css-modules",
        "Huuums.vscode-fast-folder-structure"
  ]
 }
@@ -1,28 +1,47 @@
 {
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
    "configurations": [
        {
            "name": "Electron: Main",
            "type": "node",
            "request": "launch",
            "protocol": "inspector",
            "runtimeExecutable": "npm",
            "runtimeArgs": ["run start:main --inspect=5858 --remote-debugging-port=9223"],
            "preLaunchTask": "Start Webpack Dev"
        },
        {
            "name": "Electron: Renderer",
            "type": "chrome",
            "request": "attach",
            "port": 9223,
            "webRoot": "${workspaceFolder}",
            "timeout": 15000
        }
    ],
  "compounds": [
    {
-            "name": "Electron: All",
+      "name": "Debug App",
-            "configurations": ["Electron: Main", "Electron: Renderer"]
+      "preLaunchTask": "start .debug.script.mjs",
      "configurations": [
        "Debug Main Process",
        "Debug Renderer Process"
      ],
      "presentation": {
        "hidden": false,
        "group": "",
        "order": 1
      },
      "stopAll": true
    }
  ],
  "configurations": [
    {
      "name": "Debug Main Process",
      "type": "pwa-node",
      "request": "launch",
      "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron",
      "windows": {
        "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron.cmd"
      },
      "runtimeArgs": [
        "--no-sandbox",
        "--remote-debugging-port=9229",
        "."
      ],
      "envFile": "${workspaceFolder}/.vscode/.debug.env",
      "console": "integratedTerminal"
    },
    {
      "name": "Debug Renderer Process",
      "port": 9229,
      "request": "attach",
      "type": "pwa-chrome",
      "timeout": 60000
    },
  ]
 }
@@ -1,72 +0,0 @@
 {
    "files.associations": {
        ".eslintrc": "jsonc",
        ".prettierrc": "jsonc",
        ".eslintignore": "ignore"
    },
    "eslint.validate": ["typescript"],
    "eslint.workingDirectories": [
        { "directory": "./", "changeProcessCWD": true },
        { "directory": "./server", "changeProcessCWD": true }
    ],
    "typescript.tsserver.experimental.enableProjectDiagnostics": true,
    "editor.codeActionsOnSave": {
        "source.fixAll.eslint": "explicit",
        "source.fixAll.stylelint": "explicit",
        "source.organizeImports": "never",
        "source.formatDocument": "explicit"
    },
    "css.validate": true,
    "less.validate": false,
    "scss.validate": true,
    "scss.lint.unknownAtRules": "warning",
    "scss.lint.unknownProperties": "warning",
    "javascript.validate.enable": false,
    "javascript.format.enable": false,
    "typescript.format.enable": false,
    "search.exclude": {
        ".git": true,
        ".eslintcache": true,
        ".erb/dll": true,
        "release/{build,app/dist}": true,
        "node_modules": true,
        "npm-debug.log.*": true,
        "test/**/__snapshots__": true,
        "package-lock.json": true,
        "*.{css,sass,scss}.d.ts": true
    },
    "i18n-ally.localesPaths": ["src/i18n", "src/i18n/locales"],
    "typescript.tsdk": "node_modules\\typescript\\lib",
    "typescript.preferences.importModuleSpecifier": "non-relative",
    "stylelint.validate": ["css", "scss", "typescript", "typescriptreact"],
    "typescript.updateImportsOnFileMove.enabled": "always",
    "[typescript]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
    "[typescriptreact]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
    "typescript.format.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces": true,
    "folderTemplates.structures": [
        {
            "name": "TypeScript Feature Component With CSS Modules",
            "omitParentDirectory": true,
            "structure": [
                {
                    "fileName": "<FTName | kebabcase>.tsx",
                    "template": "Functional Component with CSS Modules"
                },
                {
                    "fileName": "<FTName | kebabcase>.module.scss"
                }
            ]
        }
    ],
    "folderTemplates.fileTemplates": {
        "Functional Component with CSS Modules": [
            "import styles from './<FTName | kebabcase>.module.scss';",
            "",
            "interface <FTName | pascalcase>Props {}",
            "",
            "export const <FTName | pascalcase> = ({}: <FTName | pascalcase>Props) => {",
            "  return <div></div>;",
            "};"
        ]
    }
 }
@@ -1,25 +1,34 @@
 {
  // See https://go.microsoft.com/fwlink/?LinkId=733558 
  // for the documentation about the tasks.json format
  "version": "2.0.0",
  "tasks": [
    {
-            "type": "npm",
+      "label": "start .debug.script.mjs",
-            "label": "Start Webpack Dev",
+      "type": "shell",
-            "script": "start:renderer",
+      "command": "node .vscode/.debug.script.mjs",
            "options": {
                "cwd": "${workspaceFolder}"
            },
      "isBackground": true,
      "problemMatcher": {
-                "owner": "custom",
+        "owner": "typescript",
        "fileLocation": "relative",
        "pattern": {
-                    "regexp": "____________"
+          // TODO: correct "regexp"
          "regexp": "^([a-zA-Z]\\:\/?([\\w\\-]\/?)+\\.\\w+):(\\d+):(\\d+): (ERROR|WARNING)\\: (.*)$",
          "file": 1,
          "line": 3,
          "column": 4,
          "code": 5,
          "message": 6
        },
        "background": {
          "activeOnStart": true,
-                    "beginsPattern": "Compiling\\.\\.\\.$",
+          "endsPattern": "^.*[startup] Electron App.*$",
                    "endsPattern": "(Compiled successfully|Failed to compile)\\.$"
        }
      }
    }
  ]
 }
 // https://code.visualstudio.com/docs/editor/tasks#_operating-system-specific-properties
 // https://code.visualstudio.com/docs/editor/tasks#_background-watching-tasks
 // https://code.visualstudio.com/docs/editor/tasks#_can-a-background-task-be-used-as-a-prelaunchtask-in-launchjson
@@ -1,5 +0,0 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
@@ -1,22 +0,0 @@
 # --- Builder stage
 FROM node:18-alpine as builder
 WORKDIR /app
 #Copy package.json first to cache node_modules
 COPY package.json package-lock.json .
 # Scripts include electron-specific dependencies, which we don't need
 RUN npm install --legacy-peer-deps --ignore-scripts
 #Copy code and build with cached modules
 COPY . .
 RUN npm run build:web
 # --- Production stage
 FROM nginx:alpine-slim
 COPY --chown=nginx:nginx --from=builder /app/release/app/dist/web /usr/share/nginx/html
 COPY ./settings.js.template /etc/nginx/templates/settings.js.template
 COPY ng.conf.template /etc/nginx/templates/default.conf.template
 ENV PUBLIC_PATH="/"
 EXPOSE 9180
 CMD ["nginx", "-g", "daemon off;"]
@@ -1,165 +1,15 @@
-<img src="assets/icons/icon.png" alt="logo" title="feishin" align="right" height="60px" />
+# Sonixd (rewrite)
-# Feishin
+Repository for the rewrite of [Sonixd](https://github.com/jeffvli/sonixd).
  <p align="center">
    <a href="https://github.com/jeffvli/feishin/blob/main/LICENSE">
      <img src="https://img.shields.io/github/license/jeffvli/feishin?style=flat-square&color=brightgreen"
      alt="License">
    </a>
      <a href="https://github.com/jeffvli/feishin/releases">
      <img src="https://img.shields.io/github/v/release/jeffvli/feishin?style=flat-square&color=blue"
      alt="Release">
    </a>
    <a href="https://github.com/jeffvli/feishin/releases">
      <img src="https://img.shields.io/github/downloads/jeffvli/feishin/total?style=flat-square&color=orange"
      alt="Downloads">
    </a>
  </p>
  <p align="center">
    <a href="https://discord.gg/FVKpcMDy5f">
      <img src="https://img.shields.io/discord/922656312888811530?color=black&label=discord&logo=discord&logoColor=white"
      alt="Discord">
    </a>
    <a href="https://matrix.to/#/#sonixd:matrix.org">
      <img src="https://img.shields.io/matrix/sonixd:matrix.org?color=black&label=matrix&logo=matrix&logoColor=white"
      alt="Matrix">
    </a>
  </p>
 ---
 ## MAINTENANCE NOTICE
 Feishin is currently undergoing a major rewrite. New feature requests will not be accepted. The rewrite is being actively developed at the [audioling](https://github.com/audioling/audioling) repository.
 Follow the repository or join the discord/matrix server for updates.
 ---
 Rewrite of [Sonixd](https://github.com/jeffvli/sonixd).
 ## Features
 -   [x] MPV player backend
 -   [x] Web player backend
 -   [x] Modern UI
 -   [x] Scrobble playback to your server
 -   [x] Smart playlist editor (Navidrome)
 -   [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)
 ## Screenshots
 <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_full_screen_player.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_full_screen_player.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_artist_detail.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_artist_detail.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_detail.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_album_detail.png" width="49.5%"/></a> <a href="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_smart_playlist.png"><img src="https://raw.githubusercontent.com/jeffvli/feishin/development/media/preview_smart_playlist.png" width="49.5%"/></a>
 ## Getting Started
 ### Desktop (recommended)
 Download the [latest desktop client](https://github.com/jeffvli/feishin/releases). The desktop client is the recommended way to use Feishin. It supports both the MPV and web player backends, as well as includes built-in fetching for lyrics.
 #### macOS Notes
 If you're using a device running macOS 12 (Monterey) or higher, [check here](https://github.com/jeffvli/feishin/issues/104#issuecomment-1553914730) for instructions on how to remove the app from quarantine.
 For media keys to work, you will be prompted to allow Feishin to be a Trusted Accessibility Client. After allowing, you will need to restart Feishin for the privacy settings to take effect.
 ### Web and Docker
 Visit [https://feishin.vercel.app](https://feishin.vercel.app) to use the hosted web version of Feishin. The web client only supports the web player backend.
 Feishin is also available as a Docker image. The images are hosted via `ghcr.io` and are available to view [here](https://github.com/jeffvli/feishin/pkgs/container/feishin). You can run the container using the following commands:
 ```bash
 # Run the latest version
 docker run --name feishin -p 9180:9180 ghcr.io/jeffvli/feishin:latest
 # Build the image locally
 docker build -t feishin .
 docker run --name feishin -p 9180:9180 feishin
 ```
 #### Docker Compose
 To install via Docker Compose use the following snippit. This also works on Portainer.
 ```yaml
 services:
    feishin:
        container_name: feishin
        image: 'ghcr.io/jeffvli/feishin:latest'
        environment:
            - SERVER_NAME=jellyfin # pre defined server name
            - SERVER_LOCK=true # When true AND name/type/url are set, only username/password can be toggled
            - SERVER_TYPE=jellyfin # navidrome also works
            - SERVER_URL= # http://address:port
            - PUID=1000
            - PGID=1000
            - UMASK=002
            - TZ=America/Los_Angeles
        ports:
            - 9180:9180
        restart: unless-stopped
 ```
 ### Configuration
 1. Upon startup you will be greeted with a prompt to select the path to your MPV binary. If you do not have MPV installed, you can download it [here](https://mpv.io/installation/) or install it using any package manager supported by your OS. After inputting the path, restart the app.
 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).
    -   **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`.
 4. _Optional_ - To hard code the server url, pass the following environment variables: `SERVER_NAME`, `SERVER_TYPE` (one of `jellyfin` or `navidrome`), `SERVER_URL`. To prevent users from changing these settings, pass `SERVER_LOCK=true`. This can only be set if all three of the previous values are set.
 ## FAQ
 ### MPV is either not working or is rapidly switching between pause/play states
 First thing to do is check that your MPV binary path is correct. Navigate to the settings page and re-set the path and restart the app. If your issue still isn't resolved, try reinstalling MPV. Known working versions include `v0.35.x` and `v0.36.x`. `v0.34.x` is a known broken version.
 ### What music servers does Feishin support?
 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)
 -   [Jellyfin](https://github.com/jellyfin/jellyfin)
 -   Subsonic-compatible servers
    -   [Airsonic-Advanced](https://github.com/airsonic-advanced/airsonic-advanced)
    -   [Ampache](https://ampache.org)
    -   [Astiga](https://asti.ga/)
    -   [Funkwhale](https://www.funkwhale.audio/)
    -   [Gonic](https://github.com/sentriz/gonic)
    -   [LMS](https://github.com/epoupon/lms)
    -   [Nextcloud Music](https://apps.nextcloud.com/apps/music)
    -   [Supysonic](https://github.com/spl0k/supysonic)
    -   More (?)
 ### I have the issue "The SUID sandbox helper binary was found, but is not configured correctly" on Linux
 This happens when you have user (unprivileged) namespaces disabled (`sysctl kernel.unprivileged_userns_clone` returns 0). You can fix this by either enabling unprivileged namespaces, or by making the `chrome-sandbox` Setuid.
 ```bash
 chmod 4755 chrome-sandbox
 sudo chown root:root chrome-sandbox
 ```
 Ubunutu 24.04 specifically introduced breaking changes that affect how namespaces work. Please see https://discourse.ubuntu.com/t/ubuntu-24-04-lts-noble-numbat-release-notes/39890#:~:text=security%20improvements%20 for possible fixes.
 ## Development
-Built and tested using Node `v16.15.0`.
+TBD
-This project is built off of [electron-react-boilerplate](https://github.com/electron-react-boilerplate/electron-react-boilerplate) v4.6.0.
+### Developing with Docker Compose
-## Translation
+TBD
 This project uses [Weblate](https://hosted.weblate.org/projects/feishin/) for translations. If you would like to contribute, please visit the link and submit a translation.
 ## License
-[GNU General Public License v3.0 ©](https://github.com/jeffvli/feishin/blob/dev/LICENSE)
+[GNU General Public License v3.0 ©](https://github.com/jeffvli/sonixd-rewrite/blob/dev/LICENSE)
@@ -1,31 +0,0 @@
 type Styles = Record<string, string>;
 declare module '*.svg' {
    const content: string;
    export default content;
 }
 declare module '*.png' {
    const content: string;
    export default content;
 }
 declare module '*.jpg' {
    const content: string;
    export default content;
 }
 declare module '*.scss' {
    const content: Styles;
    export default content;
 }
 declare module '*.sass' {
    const content: Styles;
    export default content;
 }
 declare module '*.css' {
    const content: Styles;
    export default content;
 }
@@ -1,10 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
  <dict>
    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
    <true/>
    <key>com.apple.security.cs.allow-jit</key>
    <true/>
  </dict>
 </plist>
@@ -1,13 +0,0 @@
 version: '3.5'
 services:
    feishin:
        container_name: feishin
        image: ghcr.io/jeffvli/feishin:latest
        restart: unless-stopped
        ports:
            - 9180:9180
        environment:
            - SERVER_NAME=jellyfin # pre defined server name
            - SERVER_LOCK=true # When true AND name/type/url are set, only username/password can be toggled
            - SERVER_TYPE=jellyfin # navidrome also works
            - SERVER_URL= # http://address:port
@@ -0,0 +1,59 @@
 {
  "appId": "TEST",
  "productName": "TEST",
  "copyright": "Copyright © 2022 ${author}",
  "directories": {
    "app": "release/app",
    "output": "release/build",
    "buildResources": "electron/resources"
  },
  "extends": null,
  "asar": true,
  "asarUnpack": ["**\\*.{node,dll}", "prisma"],
  "files": [
    "dist",
    "node_modules",
    "package.json",
    "prisma/**/*",
    "resources/**/*",
    "!**/node_modules/@prisma/engines/introspection-engine*",
    "!**/node_modules/@prisma/engines/migration-engine*",
    "!**/node_modules/@prisma/engines/prisma-fmt*",
    "!**/node_modules/@prisma/engines/query_engine-*",
    "!**/node_modules/@prisma/engines/libquery_engine*",
    "!**/node_modules/prisma/query_engine*",
    "!**/node_modules/prisma/libquery_engine*",
    "!**/node_modules/prisma/**/*.mjs"
  ],
  "win": {
    "target": [
      {
        "target": "nsis",
        "arch": ["x64"]
      }
    ],
    "artifactName": "${productName}-Windows-${version}-Setup.${ext}"
  },
  "nsis": {
    "oneClick": false,
    "perMachine": false,
    "allowToChangeInstallationDirectory": true,
    "deleteAppDataOnUninstall": false
  },
  "mac": {
    "target": ["dmg"],
    "artifactName": "${productName}-Mac-${version}-Installer.${ext}"
  },
  "linux": {
    "icon": "electron/resources/iconset",
    "target": ["AppImage", "deb"],
    "artifactName": "${productName}-Linux-${version}.${ext}"
  },
  "extraResources": [
    "./assets/**",
    "prisma/**/*",
    "node_modules/@prisma/engines/migration-engine*",
    "node_modules/@prisma/engines/query*",
    "node_modules/@prisma/engines/libquery*"
  ]
 }
@@ -0,0 +1,11 @@
 /// <reference types="vite-electron-plugin/electron-env" />
 declare namespace NodeJS {
  interface ProcessEnv {
    DIST: string;
    DIST_ELECTRON: string;
    /** /dist/ or /public/ */
    PUBLIC: string;
    VSCODE_DEBUG?: 'true';
  }
 }
@@ -0,0 +1,126 @@
 import fs from 'fs';
 import path from 'path';
 import { PrismaClient } from '@prisma/client';
 import { app, ipcMain } from 'electron';
 import isDev from 'electron-is-dev';
 import './server';
 const dbPath = isDev
  ? path.join(__dirname, '../../../../prisma/dev.db')
  : path.join(app.getPath('userData'), 'database.db');
 if (!isDev) {
  try {
    // database file does not exist, need to create
    fs.copyFileSync(path.join(process.resourcesPath, 'prisma/dev.db'), dbPath, fs.constants.COPYFILE_EXCL);
    console.log(`DB does not exist. Create new DB from ${path.join(process.resourcesPath, 'prisma/dev.db')}`);
  } catch (err) {
    if (err && 'code' in (err as { code: string }) && (err as { code: string }).code !== 'EEXIST') {
      console.error(`DB creation faild. Reason:`, err);
    } else {
      throw err;
    }
  }
 }
 function getPlatformName(): string {
  const isDarwin = process.platform === 'darwin';
  if (isDarwin && process.arch === 'arm64') {
    return `${process.platform}Arm64`;
  }
  return process.platform;
 }
 const platformToExecutables: Record<string, any> = {
  darwin: {
    migrationEngine: 'node_modules/@prisma/engines/migration-engine-darwin',
    queryEngine: 'node_modules/@prisma/engines/libquery_engine-darwin.dylib.node',
  },
  darwinArm64: {
    migrationEngine: 'node_modules/@prisma/engines/migration-engine-darwin-arm64',
    queryEngine: 'node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node',
  },
  linux: {
    migrationEngine: 'node_modules/@prisma/engines/migration-engine-debian-openssl-1.1.x',
    queryEngine: 'node_modules/@prisma/engines/libquery_engine-debian-openssl-1.1.x.so.node',
  },
  win32: {
    migrationEngine: 'node_modules/@prisma/engines/migration-engine-windows.exe',
    queryEngine: 'node_modules/@prisma/engines/query_engine-windows.dll.node',
  },
 };
 const extraResourcesPath = app.getAppPath().replace('app.asar', ''); // impacted by extraResources setting in electron-builder.yml
 const platformName = getPlatformName();
 const mePath = path.join(extraResourcesPath, platformToExecutables[platformName].migrationEngine);
 const qePath = path.join(extraResourcesPath, platformToExecutables[platformName].queryEngine);
 ipcMain.on('config:get-app-path', (event) => {
  event.returnValue = app.getAppPath();
 });
 ipcMain.on('config:get-platform-name', (event) => {
  const isDarwin = process.platform === 'darwin';
  event.returnValue =
    isDarwin && process.arch === 'arm64' ? `${process.platform}Arm64` : (event.returnValue = process.platform);
 });
 ipcMain.on('config:get-prisma-db-path', (event) => {
  event.returnValue = dbPath;
 });
 ipcMain.on('config:get-prisma-me-path', (event) => {
  event.returnValue = mePath;
 });
 ipcMain.on('config:get-prisma-qe-path', (event) => {
  event.returnValue = qePath;
 });
 export const prisma = new PrismaClient({
  datasources: {
    db: {
      url: `file:${dbPath}`,
    },
  },
  errorFormat: 'minimal',
  // see https://github.com/prisma/prisma/discussions/5200
  // __internal: {
  //   engine: {
  //     binaryPath: qePath,
  //   },
  // },
 });
 prisma.server.findMany({
  where: {},
 });
 export const exclude = <T, Key extends keyof T>(resultSet: T, ...keys: Key[]): Omit<T, Key> => {
  // eslint-disable-next-line no-restricted-syntax
  for (const key of keys) {
    delete resultSet[key];
  }
  return resultSet;
 };
 function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 prisma.$use(async (params, next) => {
  const maxRetries = 5;
  let retries = 0;
  do {
    try {
      const result = await next(params);
      return result;
    } catch (err) {
      retries += 1;
      return sleep(500);
    }
  } while (retries < maxRetries);
 });
@@ -0,0 +1,12 @@
 import { ipcMain } from 'electron';
 import { prisma } from '..';
 export enum ServerApi {
  GET_SERVER = 'api:server:get-server',
  GET_SERVERS = 'api:server:get-servers',
 }
 ipcMain.handle(ServerApi.GET_SERVERS, async () => {
  const result = await prisma.server.findMany();
  return result;
 });
@@ -0,0 +1,2 @@
 import './mpv-player';
 import './api';
@@ -0,0 +1,134 @@
 import { ipcMain } from 'electron';
 import MpvAPI from 'node-mpv';
 import { getWindow } from '../../..';
 const mpv = new MpvAPI(
  {
    audio_only: true,
    auto_restart: true,
    binary: 'C:/ProgramData/chocolatey/lib/mpv.install/tools/mpv.exe',
    time_update: 1,
  },
  ['--gapless-audio=yes', '--prefetch-playlist']
 );
 mpv.start().catch((error: any) => {
  console.log('error', error);
 });
 mpv.on('status', (status: any) => {
  if (status.property === 'playlist-pos') {
    if (status.value !== 0) {
      getWindow()?.webContents.send('renderer-player-auto-next');
    }
  }
 });
 // Automatically updates the play button when the player is playing
 mpv.on('started', () => {
  getWindow()?.webContents.send('renderer-player-play');
 });
 // Automatically updates the play button when the player is stopped
 mpv.on('stopped', () => {
  getWindow()?.webContents.send('renderer-player-stop');
 });
 // Automatically updates the play button when the player is paused
 mpv.on('paused', () => {
  getWindow()?.webContents.send('renderer-player-pause');
 });
 mpv.on('quit', () => {
  console.log('mpv quit');
 });
 // Event output every interval set by time_update, used to update the current time
 mpv.on('timeposition', (time: number) => {
  getWindow()?.webContents.send('renderer-player-current-time', time);
 });
 mpv.on('seek', () => {
  console.log('mpv seek');
 });
 // Starts the player
 ipcMain.on('player-play', async () => {
  await mpv.play();
 });
 // Pauses the player
 ipcMain.on('player-pause', async () => {
  await mpv.pause();
 });
 // Stops the player
 ipcMain.on('player-stop', async () => {
  await mpv.stop();
 });
 // Stops the player
 ipcMain.on('player-next', async () => {
  await mpv.next();
 });
 // Stops the player
 ipcMain.on('player-previous', async () => {
  await mpv.prev();
 });
 // Seeks forward or backward by the given amount of seconds
 ipcMain.on('player-seek', async (_event, time: number) => {
  await mpv.seek(time);
 });
 // Seeks to the given time in seconds
 ipcMain.on('player-seek-to', async (_event, time: number) => {
  await mpv.goToPosition(time);
 });
 // Sets the queue in position 0 and 1 to the given data. Used when manually starting a song or using the next/prev buttons
 ipcMain.on('player-set-queue', async (_event, data: any) => {
  if (data.queue.current) {
    await mpv.load(data.queue.current.streamUrl, 'replace');
  }
  if (data.queue.next) {
    await mpv.load(data.queue.next.streamUrl, 'append');
  }
 });
 // Replaces the queue in position 1 to the given data
 ipcMain.on('player-set-queue-next', async (_event, data: any) => {
  const size = await mpv.getPlaylistSize();
  if (size > 1) {
    await mpv.playlistRemove(1);
  }
  if (data.queue.next) {
    await mpv.load(data.queue.next.streamUrl, 'append');
  }
 });
 // Sets the next song in the queue when reaching the end of the queue
 ipcMain.on('player-auto-next', async (_event, data: any) => {
  // Always keep the current song as position 0 in the mpv queue
  // This allows us to easily set update the next song in the queue without
  // disturbing the currently playing song
  await mpv.playlistRemove(0);
  if (data.queue.next) {
    await mpv.load(data.queue.next.streamUrl, 'append');
  }
 });
 // Sets the volume to the given value (0-100)
 ipcMain.on('player-volume', async (_event, value: number) => {
  mpv.volume(value);
 });
 // Toggles the mute status
 ipcMain.on('player-mute', async () => {
  mpv.mute();
 });
@@ -0,0 +1,3 @@
 import './core';
 require(`./${process.platform}`);
@@ -0,0 +1,109 @@
 // The built directory structure
 //
 // ├─┬ dist-electron
 // │ ├─┬ main
 // │ │ └── index.js    > Electron-Main
 // │ └─┬ preload
 // │   └── index.js    > Preload-Scripts
 // ├─┬ dist
 // │ └── index.html    > Electron-Renderer
 //
 process.env.DIST_ELECTRON = join(__dirname, '..');
 process.env.DIST = join(process.env.DIST_ELECTRON, '../dist');
 process.env.PUBLIC = app.isPackaged ? process.env.DIST : join(process.env.DIST_ELECTRON, '../public');
 import { release } from 'os';
 import { join } from 'path';
 import { app, BrowserWindow, shell, ipcMain } from 'electron';
 import './features';
 // Disable GPU Acceleration for Windows 7
 if (release().startsWith('6.1')) app.disableHardwareAcceleration();
 // Set application name for Windows 10+ notifications
 if (process.platform === 'win32') app.setAppUserModelId(app.getName());
 if (!app.requestSingleInstanceLock()) {
  app.quit();
  process.exit(0);
 }
 let win: BrowserWindow | null = null;
 // Here, you can also use other preload
 const preload = join(__dirname, '../preload/index.js');
 const url = process.env.VITE_DEV_SERVER_URL as string;
 const indexHtml = join(process.env.DIST, 'index.html');
 async function createWindow() {
  win = new BrowserWindow({
    icon: join(process.env.PUBLIC as string, 'favicon.svg'),
    title: 'Main window',
    webPreferences: {
      contextIsolation: true,
      nodeIntegration: false,
      preload,
    },
  });
  if (app.isPackaged) {
    win.loadFile(indexHtml);
  } else {
    win.loadURL(url);
    // win.webContents.openDevTools()
  }
  // Test actively push message to the Electron-Renderer
  win.webContents.on('did-finish-load', () => {
    win?.webContents.send('main-process-message', new Date().toLocaleString());
  });
  // Make all links open with the browser, not with the application
  win.webContents.setWindowOpenHandler(({ url }) => {
    if (url.startsWith('https:')) shell.openExternal(url);
    return { action: 'deny' };
  });
 }
 app.whenReady().then(createWindow);
 app.on('window-all-closed', () => {
  win = null;
  if (process.platform !== 'darwin') app.quit();
 });
 app.on('second-instance', () => {
  if (win) {
    // Focus on the main window if the user tried to open another
    if (win.isMinimized()) win.restore();
    win.focus();
  }
 });
 app.on('activate', () => {
  const allWindows = BrowserWindow.getAllWindows();
  if (allWindows.length) {
    allWindows[0].focus();
  } else {
    createWindow();
  }
 });
 // new window example arg: new windows url
 ipcMain.handle('open-win', (event, arg) => {
  const childWindow = new BrowserWindow({
    webPreferences: {
      preload,
    },
  });
  if (app.isPackaged) {
    childWindow.loadFile(indexHtml, { hash: arg });
  } else {
    childWindow.loadURL(`${url}/#${arg}`);
    // childWindow.webContents.openDevTools({ mode: "undocked", activate: true })
  }
 });
 export const getWindow = () => {
  return win;
 };
@@ -0,0 +1,107 @@
 import { contextBridge, ipcRenderer } from 'electron';
 function domReady(condition: DocumentReadyState[] = ['complete', 'interactive']) {
  return new Promise((resolve) => {
    if (condition.includes(document.readyState)) {
      resolve(true);
    } else {
      document.addEventListener('readystatechange', () => {
        if (condition.includes(document.readyState)) {
          resolve(true);
        }
      });
    }
  });
 }
 const safeDOM = {
  append(parent: HTMLElement, child: HTMLElement) {
    if (!Array.from(parent.children).find((e) => e === child)) {
      return parent.appendChild(child);
    }
  },
  remove(parent: HTMLElement, child: HTMLElement) {
    if (Array.from(parent.children).find((e) => e === child)) {
      return parent.removeChild(child);
    }
  },
 };
 /**
 * https://tobiasahlin.com/spinkit
 * https://connoratherton.com/loaders
 * https://projects.lukehaas.me/css-loaders
 * https://matejkustec.github.io/SpinThatShit
 */
 function useLoading() {
  const className = `loaders-css__square-spin`;
  const styleContent = `
@keyframes square-spin {
  25% { transform: perspective(100px) rotateX(180deg) rotateY(0); }
  50% { transform: perspective(100px) rotateX(180deg) rotateY(180deg); }
  75% { transform: perspective(100px) rotateX(0) rotateY(180deg); }
  100% { transform: perspective(100px) rotateX(0) rotateY(0); }
 }
 .${className} > div {
  animation-fill-mode: both;
  width: 50px;
  height: 50px;
  background: #fff;
  animation: square-spin 3s 0s cubic-bezier(0.09, 0.57, 0.49, 0.9) infinite;
 }
 .app-loading-wrap {
  position: fixed;
  top: 0;
  left: 0;
  width: 100vw;
  height: 100vh;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #282c34;
  z-index: 9;
 }
    `;
  const oStyle = document.createElement('style');
  const oDiv = document.createElement('div');
  oStyle.id = 'app-loading-style';
  oStyle.innerHTML = styleContent;
  oDiv.className = 'app-loading-wrap';
  oDiv.innerHTML = `<div class="${className}"><div></div></div>`;
  return {
    appendLoading() {
      safeDOM.append(document.head, oStyle);
      safeDOM.append(document.body, oDiv);
    },
    removeLoading() {
      safeDOM.remove(document.head, oStyle);
      safeDOM.remove(document.body, oDiv);
    },
  };
 }
 // ----------------------------------------------------------------------
 const { appendLoading, removeLoading } = useLoading();
 domReady().then(appendLoading);
 window.onmessage = (ev) => {
  ev.data.payload === 'removeLoading' && removeLoading();
 };
 setTimeout(removeLoading, 4999);
 const serverApi = {
  getServer: () => ipcRenderer.invoke('api:server:get-server'), // ServerApi.GET_SERVER
  getServers: () => ipcRenderer.invoke('api:server:get-servers'), // ServerApi.GET_SERVERS
 };
 const api = {
  prisma: {
    server: serverApi,
  },
 };
 contextBridge.exposeInMainWorld('electron', api);
@@ -0,0 +1,14 @@
 <!DOCTYPE html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/src/assets/favicon.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline';" />
    <title>Vite App</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
 </html>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jeffvli	ade1b8f69c	Cleanup	2022-10-06 21:28:57 -07:00
Jeffrey Li	06914b3af4	Add preliminary prisma support	2022-10-06 21:17:40 -07:00
Jeffrey Li	95c52d8a11	Initial commit	2022-10-06 15:52:01 -07:00
		`@@ -1,3 +0,0 @@`
			`/* eslint import/no-unresolved: off, import/no-self-import: off */`

			`module.exports = require('./webpack.config.renderer.dev').default;`
		`@@ -1,3 +0,0 @@`
			`# These are supported funding model platforms`

			`ko_fi: jeffvli`
		`@@ -0,0 +1,3 @@`
							`import './core';`

							require(`./${process.platform}`);