@maka/maka-cli 5.3.1 → 5.3.2

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

@@ -0,0 +1,868 @@
+// Scaffold
+import path from 'path';
+import fs from 'fs';
+import util from 'util';
+import { exec } from 'child_process';
+import { rimraf } from 'rimraf';
+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 rimraf(entryFullPath);
+            }
+        }
+    }
+    /**
+     * 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 new 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 new 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
+                await 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