@maka/maka-cli 5.2.5 → 5.2.6

package/bundle/typescript/src/tools/scaffold/scaffold.class.js

@@ -1,868 +0,0 @@
-// Scaffold
-import path from 'path';
-import fs from 'fs';
-import util from 'util';
-import { exec } from 'child_process';
-import del from 'delete';
-import ejs from 'ejs';
-import { pascalCase } from "change-case";
-import { Log } from '../log/log.class.js';
-const errorHandler = (caller, error) => {
-    if (process.env['MAKA_DEV'] === 'True') {
-        Log.error(`Error in ${caller}`);
-    }
-    if (error) {
-        console.error(error);
-    }
-};
-const isWin = process.platform === 'win32';
-const treeSymbol = (isWin) ? ' ->' : ' \u2517';
-export class Scaffold {
-    static instance;
-    fsi;
-    mpi;
-    constructor(fsi, mpi) {
-        this.fsi = fsi;
-        this.mpi = mpi;
-    }
-    // Static method to get the singleton instance
-    static getInstance(fsi, mpi) {
-        if (!Scaffold.instance) {
-            Scaffold.instance = new Scaffold(fsi, mpi);
-        }
-        return Scaffold.instance;
-    }
-    async createEmptyMeteorProject(name, opts) {
-        opts.cwd = opts.cwd || '.';
-        const appPath = path.join(opts.cwd, name);
-        const meteorPath = path.join(appPath, '.meteor');
-        if (this.fsi.isDirectory(meteorPath)) {
-            throw new Error('Meteor project already exists at ' + JSON.stringify(appPath));
-        }
-        const minFlag = '--minimal';
-        const projectDirectory = path.join(opts.cwd);
-        // Convert the callback-based exec to a promise-based function
-        const execPromise = util.promisify(exec);
-        const releaseVersion = opts.release ? `--release ${opts.release}` : '';
-        // Log a notice if the release is an alpha, beta, etc
-        if (opts.release && opts.release.includes('alpha')) {
-            Log.warn(`Creating a new Meteor project with an alpha release: ${opts.release}`);
-            Log.warn(`Please report any issues to https://github.com/maka-io/maka-cli/issues`);
-        }
-        try {
-            await execPromise(`${this.mpi.meteor} create ${name} ${minFlag} ${releaseVersion}`, { cwd: projectDirectory });
-        }
-        catch (error) {
-            Log.error(`\n${error.message}`);
-            throw error; // Propagate the error
-        }
-        const appDirectory = path.join(projectDirectory, name);
-        if (!fs.existsSync(appDirectory)) {
-            throw new Error(`Directory ${appDirectory} doesn't exist`);
-        }
-        const directoryEntries = fs.readdirSync(appDirectory);
-        for (const entryPath of directoryEntries) {
-            if (entryPath !== '.git' && entryPath !== '.meteor') {
-                const entryFullPath = path.join(appDirectory, entryPath);
-                await del(entryFullPath, { force: true }); // Use the promise-based version of 'del'
-            }
-        }
-    }
-    /**
-     * Returns an object with the type and engine given a srcPath.
-     * For example, given foo.bar.baz, returns { type: 'bar', engine: 'baz' }
-     */
-    engineAndTypeFromfilePath({ filePath }) {
-        try {
-            const re = /\.([A-Za-z0-9.]+)$/g;
-            let matches = filePath.match(re);
-            matches = matches && matches[0].split('.', 3);
-            if (!matches)
-                return { type: undefined, engine: undefined };
-            // matches can be an array of n length. I'll assume the last entry is the
-            // engine, and the one before that the type. If there's only one entry I'll
-            // assume the engine and type are the same. For example, template.js.js is
-            // equivalent to template.js
-            let engine = matches.pop();
-            let type = matches.pop() || engine;
-            if (engine)
-                engine = engine.replace('.', '');
-            if (type)
-                type = type.replace('.', '');
-            return {
-                type: type,
-                engine: engine
-            };
-        }
-        catch (e) {
-            errorHandler('engineAndTypeFromfilePath()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Given a path of ./foo.bar.baz of the schema ./foo.<type>.<engine>, rewrite
-     * the destination path to only use the type extension. For example,
-     *
-     * foo.css.less would be rewritten to be foo.css
-     */
-    rewriteDestinationPathForType({ pathParts, config }) {
-        try {
-            const destPath = pathParts.join(path.sep);
-            const fileType = this.engineAndTypeFromfilePath({ filePath: destPath }).type;
-            // get the engine from config for the given type
-            const engine = config?.engines[fileType];
-            // replace everything after the file type with only the file type
-            const replaceTypeWithEngineRe = new RegExp('\\.' + fileType + '\\S*$');
-            if (!fileType || !engine) {
-                return destPath;
-            }
-            else {
-                return destPath.replace(replaceTypeWithEngineRe, '.' + fileType);
-            }
-        }
-        catch (e) {
-            errorHandler('rewriteDestinationPathForType()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Given a source file with a name that follows this schema:
-     *
-     * <template-name>.<type>[.engine]
-     *
-     * Iff there is an engine defined, make sure this template file is the right one
-     * for the given engine. If there is no engine defined, assume the file is okay
-     * and return true.
-     */
-    isTemplateForEngine({ pathParts, config }) {
-        try {
-            if (!config) {
-                throw new Error("No configuration so can't determine engines.");
-            }
-            const srcPath = pathParts.join(path.sep);
-            const engineAndType = this.engineAndTypeFromfilePath({ filePath: srcPath });
-            // if the file doesn't have an extension return true
-            if (!engineAndType.type || !engineAndType.engine)
-                return true;
-            const configuredEngine = config.engines[engineAndType.type];
-            // if we haven't explicitly declared an engine, assume it's okay
-            if (!configuredEngine)
-                return true;
-            // ok we have a configured engine and a file engine so
-            // let's see if they match.
-            return configuredEngine === engineAndType.engine;
-        }
-        catch (e) {
-            errorHandler('isTemplateForEngine()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Like the function above, but doesn't change the name of the extension.
-     */
-    writeSourcePath({ pathParts = [] }) {
-        return pathParts.join(path.sep);
-    }
-    /**
-     * Given a path of ./foo.bar.baz of the schema ./foo.<type>.<engine>, rewrite
-     * the destination path to only use the engine extension. For example,
-     *
-     * foo.css.less would be rewritten to be foo.less.
-     */
-    rewriteDestinationPathForEngine({ pathParts = [], config }) {
-        try {
-            const destPath = pathParts.join(path.sep);
-            const fileType = this.engineAndTypeFromfilePath({ filePath: destPath }).type;
-            // get the engine from config for the given type
-            const engine = config?.engines[fileType];
-            // replace everything after the file type with the new
-            // engine extensions
-            const replaceTypeWithEngineRe = new RegExp('\\.' + fileType + '\\S*$');
-            if (!fileType || !engine) {
-                return destPath;
-            }
-            else {
-                return destPath.replace(replaceTypeWithEngineRe, '.' + engine);
-            }
-        }
-        catch (e) {
-            errorHandler('rewriteDestinationPathForEngine()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * If we have a srcPath of foo/bar.js and an engine for js that maps to typescript,
-     * then rewrite the path to foo/bar.js.ts.
-     *
-     * The schema for templates looks like this:
-     *
-     * <template-name>.<type>[.<engine>]
-     *
-     * You should omit the engine in the template file name if it's the same as the
-     * type. So instead of mytemplate.js.js you would just create mytemplate.js and
-     * it's assumed that the engine is js.
-     *
-     * The path paramter to this function is automatically adjusted to look for the
-     * template file for the configured engine. For example, if your js engine is
-     * 'typescript' then a src path of '/path/to/template.js' will be translated to
-     * '/path/to/template.js.ts'.
-     *
-     */
-    rewriteSourcePathForEngine({ pathParts = [], framework = 'meteor', config }) {
-        try {
-            // Join and normalize the path parts to remove redundant slashes
-            const srcPath = path.normalize(pathParts.join(path.sep));
-            // Ensure the original path ends with '.js'
-            if (!srcPath.endsWith('.js')) {
-                return srcPath;
-            }
-            const fileType = 'js'; // Set file type as js
-            if (!config?.engines || !config?.engines[fileType]) {
-                return srcPath;
-            }
-            const engine = config.engines[fileType];
-            // Define the order of extensions to try based on the engine
-            const extensionsToTry = engine === 'tsx' ? ['.js.tsx', '.js.ts', '.js'] : ['.js.jsx', '.js'];
-            for (const extension of extensionsToTry) {
-                const newPath = srcPath.replace(/\.js$/, extension);
-                const srcDirPath = path.join('templates', framework, newPath);
-                const fullPath = path.normalize(path.join(global.MAKA_COMMAND_PATH, srcDirPath));
-                // Check if the file with the current extension exists
-                if (fs.existsSync(fullPath)) {
-                    return newPath;
-                }
-            }
-            return srcPath;
-        }
-        catch (e) {
-            errorHandler('rewriteSourcePathForEngine()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Returns a path relative to lib/templates, with the source path
-     * rewritten to use the appropriate engine. See the rewriteSourcePathForEngine
-     * method above.
-     */
-    pathFromTemplates({ pathParts, framework = 'meteor', config }) {
-        try {
-            const srcPath = this.rewriteSourcePathForEngine({ pathParts, framework, config });
-            const srcDirPath = path.join(`src/templates/${framework}`, srcPath);
-            const templatePath = path.join(global.MAKA_COMMAND_PATH, '..', srcDirPath);
-            return templatePath;
-        }
-        catch (e) {
-            errorHandler('pathFromTemplates()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Returns a compiled template from srcPath using the ejs templating.
-     * A data context can be passed as the last parameter. This function
-     * lets us get a compiled template result without writing to a file. It
-     * can be useful when you want to inject some template content into an
-     * existing file, for example.
-     */
-    templateContent({ srcPath, context, framework, config }) {
-        try {
-            let tmplpath = this.pathFromTemplates({ pathParts: [srcPath], framework, config });
-            const { engine } = this.engineAndTypeFromfilePath({ filePath: tmplpath });
-            const ejsFileType = [
-                'css',
-                'scss',
-                'less',
-                'html',
-                'js',
-                'jsx',
-                'ts',
-                'tsx',
-                'json',
-                'env',
-                'yaml',
-                'template'
-            ];
-            const imageFileTypes = [
-                'png',
-                'ico'
-            ];
-            if (!this.fsi.isFile(tmplpath)) {
-                if (engine === 'jsx') {
-                    tmplpath = tmplpath.replace('.jsx', '');
-                }
-                if (engine === 'tsx') {
-                    tmplpath = tmplpath.replace('.tsx', '');
-                }
-                if (!this.fsi.isFile(tmplpath)) {
-                    throw new Error("Couldn't find a source template in " + JSON.stringify(tmplpath));
-                }
-            }
-            const tmplPathParts = tmplpath.split('.');
-            const pathParts = path.normalize(tmplpath).split(path.sep);
-            const isDockerfile = pathParts[pathParts.length - 1] === 'Dockerfile';
-            const isImage = imageFileTypes.includes(tmplPathParts[tmplPathParts.length - 1]);
-            const contents = fs.readFileSync(tmplpath);
-            if (isDockerfile) {
-                return ejs.render(contents.toString(), context).trim();
-            }
-            if (isImage) {
-                // convert binary data to base64 encoded string
-                return Buffer.from(contents).toString('base64');
-            }
-            if (!ejsFileType.includes(tmplPathParts[tmplPathParts.length - 1])) {
-                return contents.toString().trim();
-            }
-            return ejs.render(contents.toString(), context || {}).trim();
-        }
-        catch (e) {
-            errorHandler('templateContent()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Compile and write an ejs template from the srcPath to the destPath. The
-     * destPath is rewritten for the given engine. For example, if your js
-     * engine is 'coffee' then '/path/to/dest.js' will be rewritten to
-     * 'path/to/dest.coffee'
-     */
-    async template({ srcPath, destPath, context, config, framework, force = false, ignore = false }) {
-        try {
-            const imageFileTypes = [
-                'png',
-                'ico'
-            ];
-            const isImage = imageFileTypes.includes(srcPath.split('.').pop() || '');
-            const renderedTemplate = this.templateContent({ srcPath, context, framework, config }) + '\n';
-            if (context?.noRename) {
-                destPath = this.rewriteDestinationPathForType({ pathParts: [destPath], config });
-            }
-            else {
-                destPath = this.rewriteDestinationPathForEngine({ pathParts: [destPath], config });
-            }
-            const ret = await this.fsi.createFile({
-                filePath: destPath,
-                data: renderedTemplate,
-                opts: { force, isImage, absolute: false, ignore }
-            });
-            return ret;
-        }
-        catch (e) {
-            errorHandler('template()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Recursively copies a template directory (from the lib/templates directory) to
-     * the dest path following these rules:
-     *
-     *  1.  All folders in the srcPath are copied to destPath, building the folder
-     *      hierarchy as needed.
-     *  2.  Files matching the current engines (e.g. html/jade, js/coffee,
-     *      css/scss/less) are copied. Files not matching any current engines are
-     *      ignored.
-     *  3.  All files are compiled through ejs with the data context optionally
-     *      provided as a last parameter.
-     *  4.  ignore accepts an array of strings which will match files with relative
-     *      paths to the app folder to ignore.
-     */
-    async copyTemplateDirectory({ srcPath, destPath, context, ignore, keep, framework, config }) {
-        try {
-            const fullSourcePath = this.pathFromTemplates({ pathParts: [srcPath], framework, config });
-            const withoutTemplatePathParts = this.pathFromTemplates({ pathParts: [], framework, config });
-            const withoutTemplatePath = (fullpath) => {
-                return fullpath.replace(withoutTemplatePathParts, '');
-            };
-            const todestPath = (src) => {
-                return src.replace(fullSourcePath, destPath);
-            };
-            // first create the destination directory
-            await this.fsi.createDirectory({ dirPath: destPath });
-            const dirEntries = fs.readdirSync(fullSourcePath);
-            for (const srcEntryName of dirEntries) {
-                try {
-                    const fullEntryPath = path.join(fullSourcePath, srcEntryName);
-                    const relsrcPath = withoutTemplatePath(fullEntryPath);
-                    const destPath = todestPath(fullEntryPath);
-                    // Normalize paths for comparison
-                    const normalizedIgnorePaths = ignore.map(p => path.normalize(p));
-                    const normalizedEntryPath = path.normalize(path.join(srcPath, srcEntryName));
-                    if (normalizedIgnorePaths.includes(normalizedEntryPath)) {
-                        continue; // Use continue instead of return for the for...of loop
-                    }
-                    if (this.fsi.isDirectory(fullEntryPath)) {
-                        await this.copyTemplateDirectory({
-                            srcPath: relsrcPath,
-                            destPath,
-                            context,
-                            ignore,
-                            keep,
-                            framework,
-                            config
-                        });
-                    }
-                    else if (this.fsi.isFile(fullEntryPath) && this.isTemplateForEngine({ pathParts: [fullEntryPath], config })) {
-                        await this.template({
-                            srcPath: relsrcPath,
-                            destPath,
-                            context,
-                            framework,
-                            config
-                        });
-                    }
-                    else if (keep.indexOf(path.join(srcPath, srcEntryName)) >= 0 && this.fsi.isFile(fullEntryPath)) {
-                        context.noRename = true;
-                        await this.template({
-                            srcPath: relsrcPath, destPath, context, framework, config
-                        });
-                        context.noRename = false;
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                    process.exit(1);
-                }
-            }
-        }
-        catch (e) {
-            errorHandler('copyTemplateDirectory()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Inject content at the top of a file. If the file
-     * doesn't exist yet, create it. If the content already exists,
-     * do not inject it again.
-     */
-    async injectAtBeginningOfFile({ filePath, content, opts }) {
-        if (!filePath) {
-            throw new Error('No filePath provided to injectAtBeginningOfFile()');
-        }
-        try {
-            if (!this.fsi.isFile(filePath)) {
-                await this.fsi.createFile({
-                    filePath,
-                    data: content
-                });
-            }
-            else {
-                let fileContent = fs.readFileSync(filePath, 'utf8');
-                // Check if the content already exists in the file
-                if (!fileContent.includes(content)) {
-                    fileContent = content + "\n" + fileContent;
-                    fs.writeFileSync(filePath, fileContent);
-                }
-                if (opts?.verbose) {
-                    Log.header(`${treeSymbol} updated file ${path.relative(process.cwd(), filePath)}`);
-                }
-            }
-        }
-        catch (e) {
-            errorHandler('injectAtBeginningOfFile()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Inject content at the end of the file. If the file
-     * doesn't exist yet, create it. If the content already exists,
-     * do not inject it again.
-     */
-    async injectAtEndOfFile({ filePath, content, opts }) {
-        try {
-            if (!this.fsi.isFile(filePath)) {
-                await this.fsi.createFile({
-                    filePath,
-                    data: content
-                });
-            }
-            else {
-                let fileContent = fs.readFileSync(filePath, 'utf8');
-                // Check if the content already exists in the file
-                if (!fileContent.includes(content)) {
-                    fileContent = fileContent + '\n' + content;
-                    fs.writeFileSync(filePath, fileContent);
-                }
-                if (opts?.verbose) {
-                    Log.header(`${treeSymbol} updated file ${path.relative(process.cwd(), filePath)}`);
-                }
-            }
-        }
-        catch (e) {
-            errorHandler('injectAtEndOfFile()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Inject content around a specified target string or strings in a file, matching and adjusting the file's indentation,
-     * but only if the content is not already present. Allows separate adjustment of the target line's indentation.
-     */
-    async injectAroundString({ filePath, aboveContent, belowContent, targetString, indentAdjustment = 0, targetIndentAdjustment = 0 }) {
-        try {
-            if (!this.fsi.isFile(filePath)) {
-                throw Log.error("No file found at path " + JSON.stringify(filePath));
-            }
-            const raw = fs.readFileSync(filePath, 'utf8');
-            // Normalize line endings in the file content
-            const normalizedRaw = raw.replace(/\r\n|\r/g, '\n');
-            const lines = normalizedRaw.split('\n');
-            // Detect the most common indentation
-            const indent = this.detectIndentation(lines);
-            // Split and normalize the above and below content into lines without indentation
-            const aboveContentLines = aboveContent.replace(/\r\n|\r/g, '\n').split('\n');
-            const belowContentLines = belowContent.replace(/\r\n|\r/g, '\n').split('\n');
-            // Build the target regular expression
-            const targetRegExp = new RegExp(Array.isArray(targetString) ? targetString.join('|') : targetString, 'i');
-            const newLines = [];
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                if (targetRegExp.test(line)) {
-                    // Adjust the indentation for the target line
-                    const adjustedTargetIndent = this.adjustIndentation(indent, targetIndentAdjustment);
-                    const adjustedTargetLine = adjustedTargetIndent + line.trim();
-                    // Check and inject aboveContentLines if not present
-                    aboveContentLines.forEach(aboveLine => {
-                        if (!normalizedRaw.includes(aboveLine.trim())) {
-                            newLines.push(this.adjustIndentation(indent, indentAdjustment) + aboveLine);
-                        }
-                    });
-                    newLines.push(adjustedTargetLine);
-                    // Check and inject belowContentLines if not present
-                    belowContentLines.forEach(belowLine => {
-                        if (!normalizedRaw.includes(belowLine.trim())) {
-                            newLines.push(this.adjustIndentation(indent, indentAdjustment) + belowLine);
-                        }
-                    });
-                }
-                else {
-                    newLines.push(line);
-                }
-            }
-            const newContent = newLines.join('\n');
-            // Write the modified content back to the file
-            fs.writeFileSync(filePath, newContent);
-            Log.header(`${treeSymbol} updated file ${path.relative(process.cwd(), filePath)}`);
-        }
-        catch (e) {
-            errorHandler('injectAroundString()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Adjusts the detected indentation by the specified amount.
-     */
-    adjustIndentation(indent, adjustment) {
-        if (adjustment === 0)
-            return indent;
-        const indentLength = indent.length + adjustment;
-        return indentLength > 0 ? indent[0].repeat(indentLength) : '';
-    }
-    /**
-     * Detects the most common indentation in the file.
-     */
-    detectIndentation(lines) {
-        let spaceCount = 0;
-        let tabCount = 0;
-        lines.forEach(line => {
-            if (line.startsWith(' ')) {
-                spaceCount++;
-            }
-            else if (line.startsWith('\t')) {
-                tabCount++;
-            }
-        });
-        // Determine the most common indentation type
-        const commonIndentType = spaceCount >= tabCount ? ' ' : '\t';
-        // Find the most common number of indent characters in lines with the common indent type
-        const indentSize = this.getCommonIndentSize(lines, commonIndentType);
-        return commonIndentType.repeat(indentSize);
-    }
-    /**
-     * Finds the most common number of indent characters of a given type in the lines.
-     */
-    getCommonIndentSize(lines, indentType) {
-        const indentSizes = lines
-            .filter(line => line && line.startsWith(indentType)) // Check if the line is defined and starts with the indent type
-            .map(line => {
-            const match = line.match(new RegExp(`^${indentType}+`));
-            return match ? match[0].length : 0; // Return the length of the match or 0 if no match
-        });
-        // If there are no indent sizes, default to 0
-        if (indentSizes.length === 0) {
-            return 0;
-        }
-        // Calculate the most common indent size
-        return this.calculateMode(indentSizes);
-    }
-    /**
-     * Calculates the mode (most frequent value) in an array.
-     */
-    calculateMode(array) {
-        const frequencyMap = array.reduce((acc, val) => {
-            acc[val] = (acc[val] || 0) + 1;
-            return acc;
-        }, {});
-        return Object.keys(frequencyMap).reduce((a, b) => {
-            const freqA = frequencyMap[+a];
-            const freqB = frequencyMap[+b];
-            return freqA > freqB ? +a : +b;
-        }, 0);
-    }
-    /**
-     * Inject content into a specific section of a file, defined by start pattern(s), but only if the content doesn't already exist.
-     */
-    async injectIntoCodeBlock({ filePath, content, begin, replace = false }) {
-        try {
-            if (!this.fsi.isFile(filePath)) {
-                throw new Error("File not found: " + filePath);
-            }
-            const raw = fs.readFileSync(filePath, 'utf8');
-            const lines = raw.split('\n');
-            let startIndex = -1;
-            let endIndex = -1;
-            let braceCount = 0;
-            let insideTargetBlock = false;
-            let contentAlreadyExists = false;
-            const beginPatterns = Array.isArray(begin) ? begin : [begin]; // Ensure begin is an array
-            // Locate the start index and check if content already exists
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i];
-                if (insideTargetBlock && line.includes('{')) {
-                    braceCount++;
-                }
-                // Check for any of the begin patterns
-                if (beginPatterns.some(pattern => line.includes(pattern))) {
-                    startIndex = i;
-                    insideTargetBlock = true;
-                    braceCount++; // Start counting braces from the function start
-                    continue; // Skip the line with the begin pattern
-                }
-                if (insideTargetBlock) {
-                    // Check if the content already exists in the target block
-                    if (line.includes(content.trim())) {
-                        contentAlreadyExists = true;
-                    }
-                    if (line.includes('}')) {
-                        braceCount--;
-                        if (braceCount === 0) {
-                            endIndex = i; // Include the line with the closing brace
-                            break;
-                        }
-                    }
-                }
-            }
-            if (startIndex === -1 || endIndex === -1) {
-                Log.error(`Unable to find the target block to inject content in ${filePath}`);
-                Log.error(`While injecting ${content}`);
-                Log.error(`Looking for ${begin}`);
-                throw new Error("Unable to find the target block to inject content.");
-            }
-            // If content already exists, skip the replacement
-            if (contentAlreadyExists) {
-                return;
-            }
-            // Construct new content
-            let newContent = lines.slice(0, startIndex + 1);
-            if (replace) {
-                newContent.push(content.trim());
-                newContent.push(lines[endIndex]); // Add the line with the closing brace
-            }
-            else {
-                newContent = newContent.concat(lines.slice(startIndex + 1, endIndex));
-                newContent.push(content.trim());
-            }
-            newContent = newContent.concat(lines.slice(endIndex + 1));
-            fs.writeFileSync(filePath, newContent.join('\n'), 'utf8');
-        }
-        catch (e) {
-            console.error("Error in injectIntoCodeBlock: ", e);
-            throw e;
-        }
-    }
-    /**
-     * Inject content at the end of the section which begins with the 'begin'
-     * parameter and ends with 'end' parameter. The begin and end parameters
-     * should be regular expressions.
-     */
-    async injectIntoFile({ filePath, content, begin, end, replace = false }) {
-        try {
-            const alreadyInjected = await this.fsi.fileContainsString(filePath, content);
-            if (alreadyInjected)
-                return;
-            if (!this.fsi.isFile(filePath)) {
-                throw Log.error("No file found to inject content into at path " + JSON.stringify(filePath));
-            }
-            const raw = fs.readFileSync(filePath, 'utf8');
-            if (!Array.isArray(begin))
-                begin = [begin];
-            if (!Array.isArray(end))
-                end = [end];
-            let modifiedContent = raw;
-            let found = false;
-            for (const b of begin) {
-                for (const e of end) {
-                    // Creating a regex to find the block where the content needs to be inserted
-                    const re = new RegExp(`(${b}[\\s\\S]*?)(${e})`, 'i');
-                    modifiedContent = raw.replace(re, (match, p1, p2) => {
-                        found = true;
-                        return replace ? `${p1}${content}${p2}` : `${p1}${content}\n${p2}`;
-                    });
-                    if (found)
-                        break;
-                }
-                if (found)
-                    break;
-            }
-            if (!found) {
-                throw new Error("No matching section found.");
-            }
-            fs.writeFileSync(filePath, modifiedContent);
-            Log.header(`${treeSymbol} updated file ${path.relative(process.cwd(), filePath)}`);
-        }
-        catch (e) {
-            errorHandler('injectIntoFile()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Inject content at the end of the section which begins with the 'begin'
-     * parameter and ends with 'end' parameter. The begin and end parameters
-  
-    /**
-     * Injects a new import at the specified position of all the imports in a JS file.
-     */
-    async injectImport({ filePath, importName, modulePath, isNamedExport, injectAtStart = false }) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf8');
-            let newImport;
-            if (isNamedExport) {
-                newImport = `import { ${importName} } from '${modulePath}';\n`;
-            }
-            else {
-                newImport = `import ${importName} from '${modulePath}';\n`;
-            }
-            const lines = content.split('\n');
-            let importInsertionIndex = 0;
-            let alreadyImported = false;
-            // Check if the import already exists in the file
-            for (const line of lines) {
-                if (line.includes(`from '${modulePath}'`) || line.includes(`from "${modulePath}"`)) {
-                    const importRegex = isNamedExport ? new RegExp(`\\b${importName}\\b`, 'g') : new RegExp(`import ${importName} from`);
-                    if (line.match(importRegex)) {
-                        alreadyImported = true;
-                        break;
-                    }
-                }
-            }
-            if (alreadyImported)
-                return;
-            if (injectAtStart) {
-                // Find the first import line number in the file
-                for (let i = 0; i < lines.length; i++) {
-                    if (lines[i].match(/^import .* from .*;$/)) {
-                        importInsertionIndex = i;
-                        break;
-                    }
-                }
-            }
-            else {
-                // Find the last import line number in the file
-                for (let i = 0; i < lines.length; i++) {
-                    if (lines[i].match(/^import .* from .*;$/)) {
-                        importInsertionIndex = i;
-                    }
-                }
-                importInsertionIndex++; // Increment to insert after the last import
-            }
-            // Insert the new import at the determined position
-            lines.splice(importInsertionIndex, 0, newImport);
-            const updatedContent = lines.join('\n');
-            fs.writeFileSync(filePath, updatedContent, 'utf8');
-        }
-        catch (e) {
-            errorHandler('injectImport()', e);
-            process.exit(1);
-        }
-    }
-    async injectTemplateModule(resourceName, projectConfig, modulePath) {
-        try {
-            // Determine the template path based on the project configuration
-            let templateBasePath;
-            if (projectConfig.engines.ssr !== 'none') {
-                templateBasePath = this.pathFromApp({ pathParts: ['imports', 'startup', 'lib', 'templates.js'], config: projectConfig });
-            }
-            else {
-                templateBasePath = this.pathFromApp({ pathParts: ['imports', 'startup', 'client', 'templates.js'], config: projectConfig });
-            }
-            // Rewrite the destination path for the engine
-            const templatePath = this.rewriteDestinationPathForEngine({
-                pathParts: [templateBasePath],
-                config: projectConfig
-            });
-            const exportString = `export { ${pascalCase(resourceName)} } from '${modulePath}';`;
-            // Check if exportString exists in the file, don't inject it again
-            const alreadyExported = await this.fsi.fileContainsString(templatePath, exportString);
-            if (!alreadyExported) {
-                // Inject the module at the end of the file
-                this.injectAtEndOfFile({
-                    filePath: templatePath,
-                    content: exportString + '\n'
-                });
-            }
-        }
-        catch (e) {
-            errorHandler('injectTemplateModule()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Inject a string into a file after a line number.
-     */
-    injectAfterLineNumber({ filePath, content, lineNumber }) {
-        try {
-            const data = fs.readFileSync(filePath).toString().split("\n");
-            data.splice(lineNumber, 0, content);
-            const text = data.join('\n');
-            fs.writeFileSync(filePath, text);
-        }
-        catch (e) {
-            errorHandler('injectAfterLineNumber()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Returns the absolute path to the given filePath relative to the app
-     * directory (e.g. my-project/app/filePath). If no app directory is
-     * found the function returns false. Rewrites the source path to use
-     * the appropriate engine. See the rewriteSourcePathForEngine method above.
-     */
-    pathFromApp({ pathParts, config }) {
-        try {
-            if (!pathParts) {
-                throw new Error('No pathParts option provided');
-            }
-            const srcPath = this.rewriteSourcePathForEngine({ pathParts, config });
-            const appDirectory = this.fsi.findAppDirectory();
-            return appDirectory ? path.join(appDirectory, srcPath) : '';
-        }
-        catch (e) {
-            errorHandler('pathFromApp()', e);
-            process.exit(1);
-        }
-    }
-    /**
-     * Just like above, but doesn't rewrite the extension.
-     */
-    pathFromAppWithNoReWrite({ pathParts, config }) {
-        try {
-            const srcPath = this.writeSourcePath({ pathParts, config });
-            const appDirectory = this.fsi.findAppDirectory();
-            if (!appDirectory) {
-                throw new Error('No app directory found');
-            }
-            return path.join(appDirectory, srcPath);
-        }
-        catch (e) {
-            errorHandler('pathFromAppWithNoReWrite()', e);
-            process.exit(1);
-        }
-    }
-}
-//# sourceMappingURL=scaffold.class.js.map