adminforth 1.1.92 → 1.1.93

package/plugins/TwoFactorsAuthPlugin/dist/modules/codeInjector.js

@@ -0,0 +1,546 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { exec, spawn } from 'child_process';
+import crypto from 'crypto';
+import filewatcher from 'filewatcher';
+import fs from 'fs';
+import fsExtra from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { promisify } from 'util';
+import { ADMIN_FORTH_ABSOLUTE_PATH, getComponentNameFromPath } from './utils.js';
+import { StylesGenerator } from './styleGenerator.js';
+let TMP_DIR;
+try {
+    TMP_DIR = os.tmpdir();
+}
+catch (e) {
+    TMP_DIR = '/tmp';
+}
+const execAsync = promisify(exec);
+function hashify(obj) {
+    return crypto.createHash('sha256').update(JSON.stringify(obj)).digest('hex');
+}
+function notifyWatcherIssue(limit) {
+    console.log('Ran out of file handles after watching %s files.', limit);
+    console.log('Falling back to polling which uses more CPU.');
+    console.log('Run ulimit -n 10000 to increase the limit for open files.');
+}
+class CodeInjector {
+    cleanup() {
+        console.log('Cleaning up...');
+        this.allWatchers.forEach((watcher) => {
+            watcher.removeAll();
+        });
+    }
+    constructor(adminforth) {
+        this.allWatchers = [];
+        this.allComponentNames = {};
+        this.srcFoldersToSync = {};
+        this.adminforth = adminforth;
+        ['SIGINT', 'SIGTERM', 'SIGQUIT']
+            .forEach(signal => process.on(signal, () => {
+            this.cleanup();
+            process.exit();
+        }));
+    }
+    // async runShell({command, verbose = false}) {
+    //   console.log(`⚙️ Running shell ${command}...`);
+    //   console.time(`${command} done in`);
+    //   const { stdout: out, stderr: err } = await execAsync(command);
+    //   console.timeEnd(`${command} done in`);
+    //   console.log(`Command ${command} output:`, out, err);
+    // }
+    runNpmShell(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ command, verbose = false, cwd }) {
+            const nodeBinary = process.execPath; // Path to the Node.js binary running this script
+            const npmPath = path.join(path.dirname(nodeBinary), 'npm'); // Path to the npm executable
+            const env = Object.assign({ VITE_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);
+            console.log(`⚙️ Running npm ${command}...`);
+            console.time(`npm ${command} done in`);
+            const { stdout: out, stderr: err } = yield execAsync(`${nodeBinary} ${npmPath} ${command}`, {
+                cwd,
+                env,
+            });
+            console.timeEnd(`npm ${command} done in`);
+            if (verbose) {
+                console.log(`npm ${command} output:`, out);
+            }
+            if (err) {
+                console.error(`npm ${command} errors/warnings:`, err);
+            }
+        });
+    }
+    rmTmpDir() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // remove spa_tmp folder if it is exists
+            try {
+                yield fs.promises.rm(CodeInjector.SPA_TMP_PATH, { recursive: true });
+            }
+            catch (e) {
+                // ignore
+            }
+        });
+    }
+    prepareSources(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filesUpdated, verbose = false }) {
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            // check SPA_TMP_PATH exists and create if not
+            try {
+                yield fs.promises.access(CodeInjector.SPA_TMP_PATH, fs.constants.F_OK);
+            }
+            catch (e) {
+                yield fs.promises.mkdir(CodeInjector.SPA_TMP_PATH, { recursive: true });
+            }
+            const icons = [];
+            let routes = '';
+            let routerComponents = '';
+            const collectAssetsFromMenu = (menu) => {
+                menu.forEach((item) => {
+                    var _a, _b, _c, _d;
+                    if (item.icon) {
+                        icons.push(item.icon);
+                    }
+                    if (item.component) {
+                        if (Object.keys(item).includes('isStaticRoute')) {
+                            if (!item.isStaticRoute) {
+                                routes += `{
+                path: '${item.path}',
+                name: '${item.path}',
+                component: () => import('${item.component}'),
+                meta: { title: '${((_a = item === null || item === void 0 ? void 0 : item.meta) === null || _a === void 0 ? void 0 : _a.title) || item.path.replace('/', '')}'}
+              },\n`;
+                            }
+                            else {
+                                routes += `{
+                path: '${item.path}',
+                name: '${item.path}',
+                component: ${getComponentNameFromPath(item.component)},
+                meta: { title: '${((_b = item === null || item === void 0 ? void 0 : item.meta) === null || _b === void 0 ? void 0 : _b.title) || item.path.replace('/', '')}'}
+              },\n`;
+                                const componentName = `${getComponentNameFromPath(item.component)}`;
+                                routerComponents += `import ${componentName} from '${item.component}';\n`;
+                            }
+                        }
+                        else {
+                            if (item.homepage) {
+                                routes += `{
+                  path: '${item.path}',
+                  name: '${item.path}',
+                  component: ${getComponentNameFromPath(item.component)},
+                  meta: { title: '${((_c = item === null || item === void 0 ? void 0 : item.meta) === null || _c === void 0 ? void 0 : _c.title) || item.path.replace('/', '')}'}
+                },\n`;
+                                const componentName = `${getComponentNameFromPath(item.component)}`;
+                                routerComponents += `import ${componentName} from '${item.component}';\n`;
+                            }
+                            else {
+                                routes += `{
+                  path: '${item.path}',
+                  name: '${item.path}',
+                  component: () => import('${item.component}'),
+                  meta: { title: '${((_d = item === null || item === void 0 ? void 0 : item.meta) === null || _d === void 0 ? void 0 : _d.title) || item.path.replace('/', '')}'}
+                },\n`;
+                            }
+                        }
+                    }
+                    if (item.children) {
+                        collectAssetsFromMenu(item.children);
+                    }
+                });
+            };
+            const registerCustomPages = (config) => {
+                if (config.customization.customPages) {
+                    config.customization.customPages.forEach((page) => {
+                        var _a, _b, _c, _d;
+                        routes += `{
+            path: '${page.path}',
+            name: '${page.path}',
+            component: () => import('${((_a = page === null || page === void 0 ? void 0 : page.component) === null || _a === void 0 ? void 0 : _a.file) || page.component}'),
+            meta: { title: '${((_b = page.meta) === null || _b === void 0 ? void 0 : _b.title) || page.path.replace('/', '')}',customLayout:${(_d = (_c = page === null || page === void 0 ? void 0 : page.component) === null || _c === void 0 ? void 0 : _c.meta) === null || _d === void 0 ? void 0 : _d.customLayout}}
+          },`;
+                    });
+                }
+            };
+            registerCustomPages(this.adminforth.config);
+            collectAssetsFromMenu(this.adminforth.config.menu);
+            if (filesUpdated) {
+                // copy only updated files
+                yield Promise.all(filesUpdated.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const src = path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa', file);
+                    const dest = path.join(CodeInjector.SPA_TMP_PATH, file);
+                    // overwrite:true can't be used to not destroy cache
+                    yield fsExtra.copy(src, dest, {
+                        dereference: true, // needed to dereference types
+                    });
+                    if (process.env.HEAVY_DEBUG) {
+                        console.log('🪲 await fsExtra.copy filtering', src, dest);
+                    }
+                })));
+            }
+            else {
+                if (process.env.HEAVY_DEBUG) {
+                    console.log(`🪲 await fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, ${CodeInjector.SPA_TMP_PATH}`);
+                }
+                // try to rm SPA_TMP_PATH/src/types directory 
+                try {
+                    yield fs.promises.rm(path.join(CodeInjector.SPA_TMP_PATH, 'src', 'types'), { recursive: true });
+                }
+                catch (e) {
+                    // ignore
+                }
+                // overwrite can't be used to not destroy cache
+                yield fsExtra.copy(path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa'), CodeInjector.SPA_TMP_PATH, {
+                    filter: (src) => {
+                        if (process.env.HEAVY_DEBUG) {
+                            console.log('🪲 await fsExtra.copy filtering', src);
+                        }
+                        return !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist');
+                    },
+                    dereference: true, // needed to dereference types
+                });
+                // copy whole custom directory
+                if ((_b = this.adminforth.config.customization) === null || _b === void 0 ? void 0 : _b.customComponentsDir) {
+                    // resolve customComponentsDir to absolute path, so ./aa will be resolved to /path/to/current/dir/aa
+                    const customCompAbsPath = path.resolve(this.adminforth.config.customization.customComponentsDir);
+                    this.srcFoldersToSync[customCompAbsPath] = './';
+                }
+                // if this.adminforth.config.customization.favicon is set, copy it to assets
+                const customFav = (_c = this.adminforth.config.customization) === null || _c === void 0 ? void 0 : _c.favicon;
+                if (customFav) {
+                    const faviconPath = path.join((_d = this.adminforth.config.customization) === null || _d === void 0 ? void 0 : _d.customComponentsDir, customFav.replace('@@/', ''));
+                    const dest = path.join(CodeInjector.SPA_TMP_PATH, 'public', 'assets', customFav.replace('@@/', ''));
+                    // make sure all folders in dest exist
+                    yield fsExtra.ensureDir(path.dirname(dest));
+                    yield fsExtra.copy(faviconPath, dest);
+                }
+                for (const [src, dest] of Object.entries(this.srcFoldersToSync)) {
+                    const to = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom', dest);
+                    if (process.env.HEAVY_DEBUG) {
+                        console.log(`🪲 await fsExtra.copy from ${src}, ${to}`);
+                    }
+                    yield fsExtra.copy(src, to, {
+                        recursive: true,
+                    });
+                }
+            }
+            //collect all 'icon' fields from resources bulkActions
+            this.adminforth.config.resources.forEach((resource) => {
+                var _a;
+                if ((_a = resource.options) === null || _a === void 0 ? void 0 : _a.bulkActions) {
+                    resource.options.bulkActions.forEach((action) => {
+                        if (action.icon) {
+                            icons.push(action.icon);
+                        }
+                    });
+                }
+            });
+            const uniqueIcons = Array.from(new Set(icons));
+            // icons are collectionName:iconName. Get list of all unique collection names:
+            const collections = new Set(icons.map((icon) => icon.split(':')[0]));
+            // package names @iconify-prerendered/vue-<collection name>
+            const packageNames = Array.from(collections).map((collection) => `@iconify-prerendered/vue-${collection}`);
+            // for each icon generate import statement
+            const iconImports = uniqueIcons.map((icon) => {
+                const [collection, iconName] = icon.split(':');
+                const PascalIconName = 'Icon' + iconName.split('-').map((part, index) => {
+                    return part[0].toUpperCase() + part.slice(1);
+                }).join('');
+                return `import { ${PascalIconName} } from '@iconify-prerendered/vue-${collection}';`;
+            }).join('\n');
+            // for each custom component generate import statement
+            const customResourceComponents = [];
+            this.adminforth.config.resources.forEach((resource) => {
+                var _a;
+                resource.columns.forEach((column) => {
+                    if (column.components) {
+                        Object.values(column.components).forEach(({ file }) => {
+                            if (!customResourceComponents.includes(file)) {
+                                if (file === undefined) {
+                                    throw new Error('file is undefined from field.components, field:' + JSON.stringify(column));
+                                }
+                                customResourceComponents.push(file);
+                            }
+                        });
+                    }
+                });
+                (Object.values(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.pageInjections) || {})).forEach((injection) => {
+                    Object.values(injection).forEach((filePathes) => {
+                        filePathes.forEach(({ file }) => {
+                            if (!customResourceComponents.includes(file)) {
+                                if (file === undefined) {
+                                    throw new Error('file is undefined');
+                                }
+                                customResourceComponents.push(file);
+                            }
+                        });
+                    });
+                });
+            });
+            customResourceComponents.forEach((filePath) => {
+                const componentName = getComponentNameFromPath(filePath);
+                this.allComponentNames[filePath] = componentName;
+            });
+            // console.log('🔧 Injecting code into Vue sources...', this.allComponentNames);
+            let customComponentsImports = '';
+            for (const [targetPath, component] of Object.entries(this.allComponentNames)) {
+                customComponentsImports += `import ${component} from '${targetPath}';\n`;
+            }
+            // Generate Vue.component statements for each icon
+            const iconComponents = uniqueIcons.map((icon) => {
+                const [collection, iconName] = icon.split(':');
+                const PascalIconName = 'Icon' + iconName.split('-').map((part, index) => {
+                    return part[0].toUpperCase() + part.slice(1);
+                }).join('');
+                return `app.component('${PascalIconName}', ${PascalIconName});`;
+            }).join('\n');
+            // Generate Vue.component statements for each custom component
+            let customComponentsComponents = '';
+            for (const name of Object.values(this.allComponentNames)) {
+                customComponentsComponents += `app.component('${name}', ${name});\n`;
+            }
+            let imports = iconImports + '\n';
+            imports += customComponentsImports + '\n';
+            if ((_e = this.adminforth.config.customization) === null || _e === void 0 ? void 0 : _e.vueUsesFile) {
+                imports += `import addCustomUses from '${this.adminforth.config.customization.vueUsesFile}';\n`;
+            }
+            // inject that code into spa_tmp/src/App.vue
+            const appVuePath = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'main.ts');
+            let appVueContent = yield fs.promises.readFile(appVuePath, 'utf-8');
+            appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH IMPORTS */', imports);
+            appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH COMPONENT REGISTRATIONS */', iconComponents + '\n' + customComponentsComponents + '\n');
+            if ((_f = this.adminforth.config.customization) === null || _f === void 0 ? void 0 : _f.vueUsesFile) {
+                appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH CUSTOM USES */', 'addCustomUses(app);');
+            }
+            yield fs.promises.writeFile(appVuePath, appVueContent);
+            // generate tailwind extend styles
+            const stylesGenerator = new StylesGenerator((_g = this.adminforth.config.customization) === null || _g === void 0 ? void 0 : _g.styles);
+            const stylesText = JSON.stringify(stylesGenerator.mergeStyles(), null, 2).slice(1, -1);
+            let tailwindConfigPath = path.join(CodeInjector.SPA_TMP_PATH, 'tailwind.config.js');
+            let tailwindConfigContent = yield fs.promises.readFile(tailwindConfigPath, 'utf-8');
+            tailwindConfigContent = tailwindConfigContent.replace('/* IMPORTANT:ADMINFORTH TAILWIND STYLES */', stylesText);
+            yield fs.promises.writeFile(tailwindConfigPath, tailwindConfigContent);
+            const routerVuePath = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'router', 'index.ts');
+            let routerVueContent = yield fs.promises.readFile(routerVuePath, 'utf-8');
+            routerVueContent = routerVueContent.replace('/* IMPORTANT:ADMINFORTH ROUTES IMPORTS */', routerComponents);
+            // inject title to index.html
+            const indexHtmlPath = path.join(CodeInjector.SPA_TMP_PATH, 'index.html');
+            let indexHtmlContent = yield fs.promises.readFile(indexHtmlPath, 'utf-8');
+            indexHtmlContent = indexHtmlContent.replace('/* IMPORTANT:ADMINFORTH TITLE */', `${this.adminforth.config.customization.title || 'AdminForth'}`);
+            indexHtmlContent = indexHtmlContent.replace('/* IMPORTANT:ADMINFORTH FAVICON */', ((_h = this.adminforth.config.customization.favicon) === null || _h === void 0 ? void 0 : _h.replace('@@/', `${this.adminforth.baseUrlSlashed}assets/`))
+                ||
+                    `${this.adminforth.baseUrlSlashed}assets/favicon.png`);
+            yield fs.promises.writeFile(indexHtmlPath, indexHtmlContent);
+            /* generate custom routes */
+            const homepageMenuItem = this.adminforth.config.menu.find((mi) => mi.homepage);
+            let childrenHomePageMenuItem = this.adminforth.config.menu.find((mi) => { var _a; return mi.children && ((_a = mi.children) === null || _a === void 0 ? void 0 : _a.find((mi) => mi.homepage)); });
+            let childrenHomepage = (_j = childrenHomePageMenuItem === null || childrenHomePageMenuItem === void 0 ? void 0 : childrenHomePageMenuItem.children) === null || _j === void 0 ? void 0 : _j.find((mi) => mi.homepage);
+            let homePagePath = (homepageMenuItem === null || homepageMenuItem === void 0 ? void 0 : homepageMenuItem.path) || `/resource/${childrenHomepage === null || childrenHomepage === void 0 ? void 0 : childrenHomepage.resourceId}`;
+            if (!homePagePath) {
+                homePagePath = ((_k = this.adminforth.config.menu.filter((mi) => mi.path)[0]) === null || _k === void 0 ? void 0 : _k.path) || `/resource/${(_l = this.adminforth.config.menu.filter((mi) => mi.children)[0]) === null || _l === void 0 ? void 0 : _l.resourceId}`;
+            }
+            routes += `{
+      path: '/',
+      name: 'home',
+      //redirect to login 
+      redirect: '${homePagePath}'
+    },\n`;
+            routerVueContent = routerVueContent.replace('/* IMPORTANT:ADMINFORTH ROUTES */', routes);
+            yield fs.promises.writeFile(routerVuePath, routerVueContent);
+            /* hash checking */
+            const spaPackageLockPath = path.join(CodeInjector.SPA_TMP_PATH, 'package-lock.json');
+            const spaPackageLock = JSON.parse(yield fs.promises.readFile(spaPackageLockPath, 'utf-8'));
+            const spaLockHash = hashify(spaPackageLock);
+            /* customPackageLock */
+            const usersPackagePath = path.join('./package.json');
+            const usersPackage = JSON.parse(yield fs.promises.readFile(usersPackagePath, 'utf-8'));
+            const usersLockPath = path.join('./package-lock.json');
+            const usersLock = JSON.parse(yield fs.promises.readFile(usersLockPath, 'utf-8'));
+            const usersLockHash = hashify(usersLock);
+            const packagesNamesHash = hashify(packageNames);
+            const fullHash = `${spaLockHash}::${packagesNamesHash}::${usersLockHash}`;
+            const hashPath = path.join(CodeInjector.SPA_TMP_PATH, 'node_modules', '.adminforth_hash');
+            try {
+                const existingHash = yield fs.promises.readFile(hashPath, 'utf-8');
+                if (existingHash === fullHash) {
+                    console.log('Hashes match, skipping npm ci/install');
+                    return;
+                }
+                else {
+                    if (verbose) {
+                        console.log(`Hashes do not match: existing ${existingHash} new ${fullHash}, proceeding with npm ci/install`);
+                    }
+                }
+            }
+            catch (e) {
+                // ignore
+                if (verbose) {
+                    console.log('Hash file does not exist, proceeding with npm ci/install');
+                }
+            }
+            yield this.runNpmShell({ command: 'ci', verbose, cwd: CodeInjector.SPA_TMP_PATH });
+            // get packages with version from customPackage
+            const IGNORE_PACKAGES = ['tsx', 'typescript', 'express', 'nodemon', 'adminforth'];
+            const customPackgeNames = [...Object.keys(usersPackage.dependencies), ...Object.keys(usersPackage.devDependencies || [])]
+                .filter((packageName) => !IGNORE_PACKAGES.includes(packageName))
+                .reduce((acc, packageName) => {
+                const version = usersLock.packages[`node_modules/${packageName}`].version;
+                acc.push(`${packageName}@${version}`);
+                return acc;
+            }, []);
+            if (packageNames.length) {
+                const npmInstallCommand = `install ${[...packageNames, ...customPackgeNames].join(' ')}`;
+                yield this.runNpmShell({ command: npmInstallCommand, cwd: CodeInjector.SPA_TMP_PATH });
+            }
+            yield fs.promises.writeFile(hashPath, fullHash);
+        });
+    }
+    watchForReprepare(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ verbose }) {
+            const spaPath = path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa');
+            // get list of all subdirectories in spa recursively
+            const directories = [];
+            const collectDirectories = (dir) => __awaiter(this, void 0, void 0, function* () {
+                const files = yield fs.promises.readdir(dir, { withFileTypes: true });
+                for (const file of files) {
+                    if (['node_modules', 'dist'].includes(file.name)) {
+                        continue;
+                    }
+                    if (file.isDirectory()) {
+                        directories.push(path.join(dir, file.name));
+                        yield collectDirectories(path.join(dir, file.name));
+                    }
+                }
+            });
+            yield collectDirectories(spaPath);
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🔎 Watching for changes in:', directories.join(','));
+            }
+            const watcher = filewatcher();
+            directories.forEach((dir) => {
+                watcher.add(dir);
+            });
+            watcher.on('change', (file, x) => __awaiter(this, void 0, void 0, function* () {
+                console.log(`File ${file} changed ${x}, preparing sources...`);
+                yield this.prepareSources({ filesUpdated: [file.replace(spaPath + '/', '')] });
+            }));
+            watcher.on('fallback', notifyWatcherIssue);
+            this.allWatchers.push(watcher);
+        });
+    }
+    watchCustomComponentsForCopy(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ verbose, customComponentsDir, destination }) {
+            if (!customComponentsDir) {
+                return;
+            }
+            // check if folder exists
+            try {
+                yield fs.promises.access(customComponentsDir, fs.constants.F_OK);
+            }
+            catch (e) {
+                if (verbose) {
+                    console.log(`Custom components dir ${customComponentsDir} does not exist, skipping watching`);
+                }
+                return;
+            }
+            // get all subdirs
+            const directories = [];
+            const files = [];
+            const collectDirectories = (dir) => __awaiter(this, void 0, void 0, function* () {
+                directories.push(dir);
+                const filesAndDirs = yield fs.promises.readdir(dir, { withFileTypes: true });
+                yield Promise.all(filesAndDirs.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const isDir = fs.lstatSync(path.join(dir, file.name)).isDirectory();
+                    if (isDir) {
+                        yield collectDirectories(path.join(dir, file.name));
+                    }
+                    else {
+                        files.push(path.join(dir, file.name));
+                    }
+                })));
+            });
+            yield collectDirectories(customComponentsDir);
+            const watcher = filewatcher();
+            files.forEach((file) => {
+                process.env.HEAVY_DEBUG && console.log(`🔎 Watching for changes in file ${file}`);
+                watcher.add(file);
+            });
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🔎 Watching for changes in:', directories.join(','));
+            }
+            watcher.on('change', (fileOrDir) => __awaiter(this, void 0, void 0, function* () {
+                // copy one file
+                const relativeFilename = fileOrDir.replace(customComponentsDir + '/', '');
+                if (process.env.HEAVY_DEBUG) {
+                    console.log(`🔎 fileOrDir ${fileOrDir} changed`);
+                    console.log(`🔎 relativeFilename ${relativeFilename}`);
+                    console.log(`🔎 customComponentsDir ${customComponentsDir}`);
+                    console.log(`🔎 destination ${destination}`);
+                }
+                const isFile = fs.lstatSync(fileOrDir).isFile();
+                if (isFile) {
+                    const destPath = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom', destination, relativeFilename);
+                    process.env.HEAVY_DEBUG && console.log(`🔎 Copying file ${fileOrDir} to ${destPath}`);
+                    yield fsExtra.copy(fileOrDir, destPath);
+                    return;
+                }
+                else {
+                    // for now do nothing
+                }
+            }));
+            watcher.on('fallback', notifyWatcherIssue);
+            this.allWatchers.push(watcher);
+        });
+    }
+    bundleNow(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ hotReload = false, verbose = false }) {
+            this.adminforth.runningHotReload = hotReload;
+            yield this.prepareSources({ verbose });
+            if (hotReload) {
+                yield Promise.all([
+                    this.watchForReprepare({ verbose }),
+                    ...Object.entries(this.srcFoldersToSync).map((_b) => __awaiter(this, [_b], void 0, function* ([src, dest]) {
+                        yield this.watchCustomComponentsForCopy({
+                            verbose,
+                            customComponentsDir: src,
+                            destination: dest,
+                        });
+                    })),
+                ]);
+            }
+            console.log('AdminForth bundling');
+            const cwd = CodeInjector.SPA_TMP_PATH;
+            if (!hotReload) {
+                // probably add option to build with tsh check (plain 'build')
+                yield this.runNpmShell({ command: 'run build-only', verbose, cwd });
+            }
+            else {
+                const command = 'run dev';
+                console.log(`⚙️ Running npm ${command}...`);
+                const nodeBinary = process.execPath;
+                const npmPath = path.join(path.dirname(nodeBinary), 'npm');
+                const env = Object.assign({ VITE_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);
+                const devServer = spawn(`${nodeBinary}`, [`${npmPath}`, ...command.split(' ')], {
+                    cwd,
+                    env,
+                });
+                devServer.stdout.on('data', (data) => {
+                    console.log(`[AdminForth SPA]:`);
+                    process.stdout.write(data);
+                });
+                devServer.stderr.on('data', (data) => {
+                    console.error(`[AdminForth SPA ERR]:`);
+                    process.stdout.write(data);
+                });
+            }
+        });
+    }
+}
+CodeInjector.SPA_TMP_PATH = path.join(TMP_DIR, 'adminforth', 'spa_tmp');
+export default CodeInjector;

package/plugins/TwoFactorsAuthPlugin/dist/modules/styleGenerator.js

@@ -0,0 +1,43 @@
+import { transformObject, deepMerge, createRGBA, parseColorForAliases, darkenRGBA, lightenRGBA } from "./utils.js";
+import { styles } from "./styles.js";
+export class StylesGenerator {
+    constructor(styleConfig) {
+        this.styleConfig = styleConfig;
+        this.defaultStyles = styles();
+    }
+    generatePlainStyles(styleObj) {
+        let plainCustomStyles = {};
+        if (styleObj) {
+            Object.keys(styleObj).forEach((k) => {
+                plainCustomStyles[k] = transformObject(styleObj[k]);
+            });
+        }
+        return plainCustomStyles;
+    }
+    changeAlias(str, mergedStyles) {
+        const { aliasMatch, opacityMatch, darkenMatch, lightenMatch } = parseColorForAliases(str);
+        if (!aliasMatch) {
+            return str;
+        }
+        else {
+            const alias = aliasMatch[1];
+            let opacity = opacityMatch ? parseFloat(opacityMatch[1]) : 1;
+            const color = mergedStyles[alias];
+            if (darkenMatch) {
+                return darkenRGBA(createRGBA(color, opacity));
+            }
+            if (lightenMatch) {
+                return lightenRGBA(createRGBA(color, opacity));
+            }
+            return createRGBA(color, opacity);
+        }
+    }
+    mergeStyles() {
+        let mergedStyles = deepMerge(this.defaultStyles, this.generatePlainStyles(this.styleConfig));
+        let colors = mergedStyles.colors;
+        Object.entries(colors).forEach(([key, value]) => {
+            colors[key] = this.changeAlias(value, colors);
+        });
+        return mergedStyles;
+    }
+}