a2r/utils/devElectron.js

A2R Framework

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const execa_1 = __importDefault(require("execa"));
const fs_1 = require("@a2r/fs");
const getProjectPath_1 = __importDefault(require("./getProjectPath"));
const getFilesRecursively_1 = __importDefault(require("../tools/getFilesRecursively"));
const copyProjectContentsToPath_1 = __importDefault(require("./copyProjectContentsToPath"));
const colors_1 = require("./colors");
const settings_1 = require("../settings");
const devElectron = async (project) => {
    const mainProjectPath = await (0, getProjectPath_1.default)();
    const a2rInternalPath = path_1.default.resolve(mainProjectPath, settings_1.projectsInternalPath);
    const currentProjectPath = path_1.default.resolve(mainProjectPath, project.path);
    const baseProjectPath = path_1.default.resolve(mainProjectPath, project.baseProject);
    const projectInternalPath = path_1.default.resolve(mainProjectPath, a2rInternalPath, project.path);
    const internalSrcPath = path_1.default.resolve(projectInternalPath, 'src');
    const internalRendererPath = path_1.default.resolve(internalSrcPath, 'renderer');
    if (await (0, fs_1.exists)(internalSrcPath)) {
        const srcFiles = await (0, fs_1.readDir)(internalSrcPath, { withFileTypes: true });
        await Promise.all(srcFiles.map(async (content) => {
            if (content.name !== 'node_modules') {
                const fullPath = path_1.default.resolve(internalSrcPath, content.name);
                if (content.isFile()) {
                    await (0, fs_1.unlink)(fullPath);
                }
                else {
                    await (0, fs_1.rimraf)(fullPath);
                }
            }
        }));
    }
    await (0, fs_1.ensureDir)(projectInternalPath);
    await (0, fs_1.ensureDir)(internalSrcPath);
    await (0, fs_1.ensureDir)(internalRendererPath);
    const pathsToIgnore = ['node_modules'];
    const filesToIgnore = ['package.json', 'package-lock.json'];
    const electronRendererPath = path_1.default.resolve(currentProjectPath, 'renderer');
    const electronFiles = await (0, getFilesRecursively_1.default)(electronRendererPath, pathsToIgnore, filesToIgnore);
    const nextFiles = await (0, getFilesRecursively_1.default)(baseProjectPath, pathsToIgnore, filesToIgnore);
    const electronFilesPaths = new Set();
    for (let i = 0, l = electronFiles.length; i < l; i++) {
        electronFilesPaths.add(path_1.default.relative(electronRendererPath, electronFiles[i]));
    }
    await (0, copyProjectContentsToPath_1.default)(currentProjectPath, internalSrcPath);
    await Promise.all(nextFiles.map(async (filePath) => {
        const relativePath = path_1.default.relative(baseProjectPath, filePath);
        if (!electronFilesPaths.has(relativePath)) {
            const destPath = path_1.default.resolve(internalRendererPath, relativePath);
            const dirPath = path_1.default.dirname(destPath);
            const check = await (0, fs_1.exists)(dirPath);
            if (!check) {
                await (0, fs_1.mkDir)(dirPath, { recursive: true });
            }
            await (0, fs_1.copyFile)(filePath, destPath);
        }
    }));
    const baseNextFiles = await (0, fs_1.readDir)(baseProjectPath, { withFileTypes: true });
    const filesToIgnoreSet = new Set(filesToIgnore);
    await Promise.all(baseNextFiles.map(async (content) => {
        if (content.isFile()) {
            if (!filesToIgnoreSet.has(content.name)) {
                const fullPath = path_1.default.resolve(baseProjectPath, content.name);
                const destPath = path_1.default.resolve(internalRendererPath, content.name);
                if (!(await (0, fs_1.exists)(destPath))) {
                    await (0, fs_1.copyFile)(fullPath, destPath);
                }
            }
        }
    }));
    const nodeModulesPath = path_1.default.resolve(internalSrcPath, 'node_modules');
    if (!(await (0, fs_1.exists)(nodeModulesPath))) {
        (0, colors_1.log)(`No modules installed, running ${(0, colors_1.terminalCommand)('npm install')}`);
        await (0, execa_1.default)('npm', ['install'], {
            cwd: internalSrcPath,
            stdout: process.stdout,
            stderr: process.stderr,
        });
    }
    (0, colors_1.log)('Running electron app');
    await (0, execa_1.default)('npm', ['run', 'dev'], {
        cwd: internalSrcPath,
        stdout: process.stdout,
        stderr: process.stderr,
    });
};
exports.default = devElectron;