@breadstone-infrastructure/nx-tasks 0.0.258 → 0.0.260

package/src/executors/lit-style-transform/executor.task.ts

@@ -1,433 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable max-depth */
-// #region Imports
-
-import { blue, bold, ConsoleLogger, File, gray, green, type IFileCache, type IFileCacheOptions, type ILogger, logSeparator, logTree, magenta, Path, red, Template, TemporaryFile, yellow } from '@breadstone-infrastructure/utilities';
-import autoprefixer from 'autoprefixer';
-import { bundle } from 'lightningcss';
-import postcss from 'postcss';
-import { type CompileResult, compileString, type OutputStyle } from 'sass';
-import type { PackageJson, TsConfigJson } from 'type-fest';
-import { withCaching } from '../../utils/withCaching';
-
-// #endregion
-
-/**
- * @description Task to generate ts from scss styles.
- * @public
- */
-export namespace LitStyleTransformTask {
-
-    export const DEFAULT_OPTIONS = {
-        nodeModulesPath: '../../../node_modules',
-        templateFile: '.build/templates/StyleTransform.ts.tpl',
-        outputStyle: 'expanded' as OutputStyle,
-        excludes: [
-            'Base.scss',
-            'All.scss',
-            'Core.scss',
-            '_BaseBorder.scss',
-            '_BaseColor.scss',
-            '_BaseElevation.scss',
-            '_BaseScheme.scss',
-            '_BaseTypography.scss',
-            '_BaseLayout.scss',
-            '_BaseTransition.scss',
-            '_BaseVar.scss',
-            '_Breakpoints.scss',
-            '_Host.scss',
-            '_Unit.scss',
-            '_Sizes.scss',
-            '_Variants.scss',
-            '_Layout.scss',
-            '_Color.scss',
-            '_Common.scss',
-            '_Elevation.scss',
-            '_Scheme.scss',
-            '_NunitoTypography.scss',
-            '_RobotoTypography.scss',
-            '_Typography.scss'
-        ],
-        verbose: false,
-        autoprefix: false,
-        force: false,
-        elementsOnly: false,
-        themes: [
-            // 'Material', // google material design
-            // 'Cupertino', // apple ios
-            // 'Fluent', // microsoft fluent design
-            // 'Bootstrap',
-            'Joy',
-            'Cosmopolitan',
-            'Memphis', // memphis style (DEPRECATED)
-            'Memphis', // Memphis is same
-            'Default'
-        ]
-    };
-
-    export interface ILitStyleTransformTaskOptions {
-        cwd: string;
-        packageJson: PackageJson;
-        tsConfigJson: TsConfigJson;
-        nodeModulesPath: string;
-        templateFile: string;
-        outputStyle: OutputStyle;
-        includes?: Array<string>;
-        excludes?: Array<string>;
-        verbose?: boolean;
-        autoprefix?: boolean;
-        force?: boolean;
-        dryRun?: boolean;
-        cache?: IFileCacheOptions;
-        themes?: Array<string>;
-
-        /**
-         * allow to only transform styles that are used in elements.
-         */
-        elementsOnly?: boolean;
-    }
-
-    export async function run(options: ILitStyleTransformTaskOptions): Promise<void> {
-        const logger = new ConsoleLogger();
-        logSeparator(logger, 'Transforming styles (Lit)');
-
-        const fileCache = withCaching(options.cache);
-
-        const scssFiles = Path.glob(options.includes ?? [], {
-            cwd: options.cwd,
-            ignore: options.excludes,
-            absolute: true
-        });
-
-        if (options.verbose) {
-            logger.log(gray(`  Found ${scssFiles.length} files to transform.`));
-            const excluded = Path.glob(options.excludes ?? [], { cwd: options.cwd });
-            excluded.forEach((x) => logger.log(gray(`  [Excluded]: ${x}`)));
-            logger.log(gray(`  Found ${excluded.length} files to exclude.`));
-        }
-
-        if (!scssFiles.length) {
-            if (options.verbose) {
-                logger.log(gray('  File or Folder is up to date.'));
-            }
-            logSeparator(logger);
-            return Promise.resolve();
-        }
-
-        const dependencyMap = buildDependencyMap(scssFiles, logger);
-
-        let hasChanges = false;
-
-        if (scssFiles.length) {
-            logger.log(magenta('  Analyzing files...'));
-
-            if (options.verbose) {
-                logger.log(gray(`  Transforming ${scssFiles.length}.`));
-            }
-
-            for (const scssFile of scssFiles) {
-                const dependencies = getInFileDependencies(scssFile);
-                const allFilesToCheck = [scssFile, ...dependencies];
-                const isCached = await areAllFilesCached(allFilesToCheck, fileCache);
-
-                let isDirtyDueToDependents = false;
-
-                for (const dep of dependencies) {
-                    const dependents = dependencyMap.get(dep);
-                    if (dependents) {
-                        for (const dependent of dependents) {
-                            const dependentIsCached = await fileCache.isFileCached(dependent);
-                            if (!dependentIsCached) {
-                                isDirtyDueToDependents = true;
-                                if (options.verbose) {
-                                    logger.log(gray(`  Dependency '${dep}' is referenced by '${dependent}', which is not cached.`));
-                                }
-                                break;
-                            } else if (options.verbose) {
-                                logger.log(gray(`  Dependency '${dep}' is referenced by '${dependent}', which is cached.`));
-                            }
-                        }
-                    }
-                    if (isDirtyDueToDependents) {
-                        // remove all cached files
-                        allFilesToCheck.forEach((file) => {
-                            const token = fileCache.getFileToken(file);
-                            fileCache.deleteFile(token);
-                        });
-
-                        break;
-                    }
-                }
-
-                if (options.force || !isCached || isDirtyDueToDependents) {
-                    hasChanges = true;
-
-                    if (options.verbose) {
-                        logger.log(gray(`  Rebuilding '${Path.relative(options.cwd, scssFile)}' because:`));
-                        if (options.force) {
-                            logger.log(yellow(`    → ${bold('Force')} flag is ${bold('enabled')}.`));
-                        }
-                        if (!isCached) {
-                            logger.log(red(`    → ${bold('Cache miss')}: File or dependencies are not cached.`));
-                        }
-                        if (isDirtyDueToDependents) {
-                            logger.log(blue(`    → ${bold('Dependency cascade')}: Dependent(s) of a dependency are dirty.`));
-                        }
-                    }
-
-                    if (!isElementStyle(scssFile, options) && options.elementsOnly) {
-                        logger.warn(`   ${yellow(bold('[WARN]'))}: '${Path.relative(options.cwd, scssFile)}' has an invalid format.`);
-                        continue;
-                    }
-
-                    const fileName = Path.getFileName(scssFile);
-                    const outName = Path.changeExtension(scssFile, '.ts');
-
-                    if (File.exists(outName)) {
-                        logTree(logger, `'${gray(Path.relative(options.cwd, scssFile))}'`, [
-                            { label: `'${Path.relative(options.cwd, outName)}'` }
-                        ], {
-                            prefix: `${blue(bold('  [UPDATE]'))}: `,
-                            prefixSpaceLength: 12,
-                            excludePrefixSpaceLengthFromRoot: true
-                        });
-                    } else {
-                        logTree(logger, `'${gray(Path.relative(options.cwd, scssFile))}'`, [
-                            { label: `'${Path.relative(options.cwd, outName)}'` }
-                        ], {
-                            prefix: `${green(bold('  [CREATE]'))}: `,
-                            prefixSpaceLength: 12,
-                            excludePrefixSpaceLengthFromRoot: true
-                        });
-                    }
-
-                    try {
-                        const renderResult = render(scssFile, options, logger);
-                        let css = renderResult.css;
-
-                        if (options.autoprefix) {
-                            if (options.verbose) {
-                                logger.log(gray('  [Prefixed]'));
-                            }
-                            css = await prefix(scssFile, css);
-                        }
-
-                        try {
-                            css = bundleCss(outName, css, options, logger);
-                        } catch (bundleError) {
-                            fileCache.deleteFile(fileCache.getFileToken(scssFile));
-                        }
-
-                        const tplPath = Path.combine(options.cwd, options.templateFile);
-                        const templateContent = File.readAllText(tplPath);
-                        const segments = Path.relative(Path.combine(options.cwd, options.tsConfigJson.compilerOptions?.rootDir ?? ''), Path.getDirectoryName(scssFile)).split(Path.separator);
-                        const relativePath = new Array(segments.length).fill('..')
-                            .join(Path.separator);
-
-                        const tpl = Template.create({
-                            relativeRootDir: relativePath,
-                            name: Path.getFileNameWithoutExtension(fileName).replace('Style', ''),
-                            content: css
-                        }).apply(templateContent)
-                            .toString();
-
-                        if (!options.dryRun) {
-                            File.writeAllText(outName, tpl);
-                        }
-
-                        // fileCache.addFile(x);
-                    } catch (error) {
-                        fileCache.deleteFile(fileCache.getFileToken(scssFile));
-                        logger.error(red(`  [ERROR] Error while transpiling '${bold(fileName)}'.`));
-                        File.writeAllText(outName, 'ERROR');
-                        process.exit(-1);
-                    }
-                } else if (options.verbose) {
-                    logger.log(`  ${gray(bold('[UPTODATE]'))}: '${Path.relative(options.cwd, scssFile)}'`);
-                }
-            }
-
-            if (!hasChanges) {
-                logger.log(gray('  Everything is up to date.'));
-            }
-        } else if (options.verbose) {
-            logger.log(gray('  File or Folder is up to date.'));
-        }
-
-        logSeparator(logger);
-        return Promise.resolve();
-    }
-}
-
-function buildDependencyMap(files: Array<string>, logger?: ILogger, verbose?: boolean): Map<string, Set<string>> {
-    const dependencyMap = new Map<string, Set<string>>();
-
-    for (const file of files) {
-        const dependencies = getInFileDependencies(file);
-        if (verbose && logger) {
-            logger.log(gray(`  [Dependency Map] ${file} depends on: ${dependencies.length > 0 ? dependencies.join(', ') : 'None'}`));
-        }
-        for (const dep of dependencies) {
-            if (!dependencyMap.has(dep)) {
-                dependencyMap.set(dep, new Set<string>());
-            }
-            dependencyMap.get(dep)?.add(file);
-        }
-    }
-
-    if (verbose && logger) {
-        logger.log(gray('  [Dependency Map Summary]'));
-        for (const [dep, dependents] of dependencyMap.entries()) {
-            logger.log(gray(`    ${dep} → `) + green(`[${Array.from(dependents).join(', ')}]`));
-        }
-    }
-
-    return dependencyMap;
-}
-
-function render(file: string, options: LitStyleTransformTask.ILitStyleTransformTaskOptions, logger: ILogger): CompileResult {
-    try {
-        if (!File.exists(file)) {
-            throw new Error(`File not found: ${file}`);
-        }
-
-        const scssContent = File.readAllText(file);
-
-        const loadPaths = [
-            Path.combine(options.cwd, options.nodeModulesPath), // Resolve dependencies inside node_modules
-            Path.getDirectoryName(file)                         // Resolve relative imports
-        ];
-
-        const result = compileString(scssContent, {
-            style: options.outputStyle,
-            url: new URL(`file://${file}`), // Needed for relative imports
-            loadPaths: loadPaths
-        });
-
-        if (options.verbose) {
-            logger.log(gray(`  [INFO]: Successfully compiled: ${file}`));
-            logger.log(gray('  [INFO]: Using load paths:'));
-            loadPaths.forEach((path) => logger.log(gray(`    - ${path}`)));
-        }
-
-        return result;
-    } catch (error) {
-        logger.error(red(`  [ERROR]: SCSS compilation failed for '${file}': ${error.message}`));
-        throw new Error('SCSS compilation failed.');
-    }
-}
-
-function bundleCss(file: string, css: string, options: LitStyleTransformTask.ILitStyleTransformTaskOptions, logger: ILogger): string {
-    const magicNumber = 18; // this is the magic number where the real css content starts in the typescript output;
-
-    const tmpFile = new TemporaryFile();
-    File.writeAllText(tmpFile.path, css);
-
-    try {
-        const result = bundle({
-            filename: tmpFile.path,
-            minify: false,
-            errorRecovery: true
-        });
-
-        if (result.warnings.length > 0) {
-            result.warnings.forEach((x) => {
-                logger.warn(yellow(`    ${yellow(bold('[WARN]'))}: ${yellow(x.message)} in '${Path.relative(options.cwd, file)}:${x.loc.line + magicNumber}:${x.loc.column}'`));
-            });
-        }
-
-        const decoder = new TextDecoder('utf-8');
-        return decoder.decode(result.code);
-    } catch (error) {
-        logger.error(red(`  [ERROR]: CSS bundle failed for '${Path.relative(options.cwd, file)}': ${error.message}`));
-        throw error;
-    } finally {
-        tmpFile.dispose();
-    }
-}
-
-async function prefix(file: string, css: string): Promise<string> {
-    try {
-        const result = await postcss([autoprefixer as any])
-            .process(css, {
-                from: undefined  // from: undefined is important for standalone processing
-            });
-        return result.css;
-    } catch (error) {
-        console.error(`  [ERROR]: Autoprefixer processing failed for '${file}': ${error.message}`);
-        return '';
-    }
-}
-
-function isElementStyle(file: string, options: LitStyleTransformTask.ILitStyleTransformTaskOptions): boolean {
-    const absoluteFilePath = Path.resolve(file);
-    const fileName = Path.getFileName(file);
-    const nameWithoutExt = Path.getFileNameWithoutExtension(fileName);
-    const parts = nameWithoutExt.split('.');
-    const baseName = parts[0];
-    const variant = parts.length > 1 ? parts[1] : null;
-
-    if (variant !== null && !(options.themes ?? []).includes(variant)) {
-        return false;
-    }
-
-    const elementName = baseName.replace('Style', '');
-
-    let currentDir = Path.getDirectoryName(absoluteFilePath);
-    while (currentDir) {
-        const possibleCodeFilePath = Path.combine(currentDir, `${elementName}.ts`);
-
-        if (File.exists(possibleCodeFilePath)) {
-            return true;
-        }
-
-        const parentDir = Path.getDirectoryName(currentDir);
-        if (parentDir === currentDir) {
-            break;
-        }
-
-        currentDir = parentDir;
-    }
-
-    return false;
-}
-
-function getInFileDependencies(file: string): Array<string> {
-    const content = File.readAllText(file);
-    const regex = /@use\s+['"]([^'"]+)['"]/g;
-    const dependencies: Array<string> = [];
-    let match = null;
-
-    while ((match = regex.exec(content)) !== null) {
-        const relativePath = match[1];
-        const absolutePath = Path.resolve(Path.getDirectoryName(file), `${relativePath}.scss`);
-
-        // Check if the file is a partial (starts with '_') and if it's a valid SCSS file
-        if (File.exists(absolutePath)) {
-            // If it's a partial (underscore), ensure it's only included if referenced
-            if (absolutePath.includes(`${Path.separator}_`)) {
-                dependencies.push(absolutePath);  // Keep partials if referenced via @use
-            } else {
-                dependencies.push(absolutePath);  // Keep regular SCSS files too
-            }
-        } else {
-            // check pseudo file
-            // if a file is not found, check if it is a pseudo file
-            // e.g. './CellElement' => './_CellElement.scss'
-            // important here is the _ prefix
-            const pseudoFile = relativePath.replace(/^\.\//, '');
-            const pseudoFilePath = Path.resolve(Path.getDirectoryName(file), `_${pseudoFile}.scss`);
-            if (File.exists(pseudoFilePath)) {
-                dependencies.push(pseudoFilePath);
-            }
-        }
-    }
-
-    return dependencies;
-}
-
-async function areAllFilesCached(files: Array<string>, fileCache: IFileCache): Promise<boolean> {
-    const cacheChecks = await Promise.all(files.map((file) => fileCache.isFileCached(file)));
-    return cacheChecks.every((result) => result);
-}

package/src/executors/lit-style-transform/executor.ts

@@ -1,47 +0,0 @@
-// #region Imports
-
-import { Path } from '@breadstone-infrastructure/utilities';
-import type { ExecutorContext } from '@nx/devkit';
-import { getProjectPackageJson } from '../../utils/getProjectPackageJson';
-import { getProjectRoot } from '../../utils/getProjectRoot';
-import { getProjectTsConfigJson } from '../../utils/getProjectTsConfigJson';
-import { isVerbose } from '../../utils/isVerbose';
-import type { LitStyleTransformTask } from './executor.task';
-
-// #endregion
-
-/**
- * @public
- */
-export default async function runExecutor(options: LitStyleTransformTask.ILitStyleTransformTaskOptions, context: ExecutorContext): Promise<{ success: boolean }> {
-    try {
-        const task = (await import('./executor.task')).LitStyleTransformTask;
-
-        await task.run({
-            cwd: getProjectRoot(context),
-            packageJson: getProjectPackageJson(context),
-            tsConfigJson: getProjectTsConfigJson(context),
-            nodeModulesPath: options.nodeModulesPath ?? task.DEFAULT_OPTIONS.nodeModulesPath,
-            templateFile: task.DEFAULT_OPTIONS.templateFile,
-            // outputStyle: (process.env.NODE_ENV ? process.env.NODE_ENV.toLowerCase().trim() : 'production') === 'production' ? 'compressed' : 'expanded',
-            outputStyle: 'expanded',
-            includes: [...options.includes ?? []],
-            excludes: [...options.excludes ?? []],
-            autoprefix: true,
-            force: false,
-            verbose: isVerbose(context, options),
-            dryRun: options.dryRun,
-            elementsOnly: options.elementsOnly ?? task.DEFAULT_OPTIONS.elementsOnly,
-            cache: {
-                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
-                dirPath: Path.combine(getProjectRoot(context), '.cache')
-            },
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            themes: task.DEFAULT_OPTIONS.themes ?? options.themes
-        });
-        return { success: true };
-    } catch (error) {
-        console.error(error);
-        return { success: false };
-    }
-}

package/src/executors/lit-style-transform/schema.json

@@ -1 +0,0 @@
-{}

package/src/executors/localizator/executor.options.ts

@@ -1,11 +0,0 @@
-// #region Imports
-
-import type { LocalizatorTask } from './executor.task';
-import type { IEnvOptions } from '../../utils/loadAndExpandDotEnvFile';
-
-// #endregion
-
-/**
- * @public
- */
-export type LocalizatorExecutorOptions = Omit<LocalizatorTask.ILocalizatorTaskOptions, 'cwd' | 'packageJson' | 'tsConfigJson'> & IEnvOptions;

package/src/executors/localizator/executor.task.ts

@@ -1,194 +0,0 @@
-/* eslint-disable complexity */
-// #region Imports
-
-import { Path, ArrayExtensions, ConsoleLogger, gray, logSeparator, logTree, magenta, red, symbol, t, yellow, bold } from '@breadstone-infrastructure/utilities';
-import { run as localizator, type IRunConfig as ILocalizatorConfig } from '@breadstone-tools/localizator-app';
-import { loadAndExpandDotEnvFile, resolveOptionTree, type IEnvOptions } from '../../utils/loadAndExpandDotEnvFile';
-
-// #endregion
-
-export namespace LocalizatorTask {
-
-    export interface ILocalizatorTaskOptions extends ILocalizatorConfig, IEnvOptions {
-        mode: 'sort' | 'analyze' | 'transform' | 'generate' | 'detect';
-    }
-
-    export async function run(options: ILocalizatorTaskOptions): Promise<void> {
-        const logger = new ConsoleLogger();
-        logSeparator(logger, 'Localizator');
-
-        try {
-            validateOptions(options);
-        } catch (error) {
-            logger.log(t`    ${red(error.message)}`);
-            return Promise.resolve();
-        }
-
-        try {
-            const env = options.envFile
-                ? loadAndExpandDotEnvFile(Path.combine(options.cwd, options.envFile), process.env)
-                : {};
-
-            if (env.error) {
-                throw new Error(`Failed to load environment variables: ${env.error.message}`);
-            }
-
-            options = resolveOptionTree(options, env);
-        } catch (error) {
-            logger.log(t`    ${red(error.message)}`);
-            return Promise.resolve();
-        }
-
-        options = extractOptionsFromMode(options);
-
-        const result = await localizator({
-            verbose: options.verbose,
-            cwd: options.cwd,
-            dryRun: options.dryRun,
-            cache: options.cache,
-            actions: {
-                detect: options.actions.detect,
-                analyze: options.actions.analyze,
-                transform: options.actions.transform,
-                sort: options.actions.sort,
-                generate: options.actions.generate
-            }
-        });
-
-        switch (options.mode) {
-            case 'sort':
-                break;
-            case 'analyze':
-                if (result.analyze && result.analyze.length > 0) {
-                    logger.log(t`  ${magenta('analyzing the project...')}`);
-
-                    for (const [key, value] of Object.entries(ArrayExtensions.groupBy(result.analyze, (x) => x.resource.name))) {
-                        logTree(logger, key, (value ?? []).map((y) => ({
-                            label: `${symbol(y.success ? 'success' : 'error')} ${y.message}`
-                        })), { prefixSpaceLength: 4 });
-                    }
-                }
-                break;
-            case 'transform':
-                // if (result.transform && result.transform.length > 0) {
-                //     logger.log(t`${magenta('Transforming resources...')}`);
-
-                //     for (const [key, value] of Object.entries(ArrayExtensions.groupBy(result.transform, (x) => x.originalResource.name))) {
-                //         logTree(logger, key, (value ?? []).map((y) => ({
-                //             label: `${y.transformedResource.name} -> ${y.transformedResource.locale}`
-                //         })), { prefixSpaceLength: 4 });
-                //     }
-                // }
-                break;
-            case 'generate':
-                if (result.generate && result.generate.length > 0) {
-                    logger.log(t`  ${magenta('generating resources...')}`);
-
-                    for (const [key, value] of Object.entries(ArrayExtensions.groupBy(result.generate, (x) => x.resource.name))) {
-                        logTree(logger, key, (value ?? []).map((y) => ({
-                            label: `${gray(y.resource.name)} -> ${bold(y.locale)}`
-                        })), { prefixSpaceLength: 4 });
-                    }
-                }
-                break;
-            case 'detect':
-                if (result.localizations && result.localizations.length > 0) {
-                    for (const x of result.localizations.filter((y) => Object.entries(y.extraction.changes).length > 0)) {
-                        const style = Object.entries(x.extraction.changes).length > 0 ? yellow : gray;
-
-                        for (const parsing of x.parsings.filter((y) => y.isStatic)) {
-                            logTree(logger, style(`${parsing.match.value}`), [{
-                                label: `${yellow('at')}: ${Path.relative(options.cwd, x.filePath)}:${parsing.lineNumber}:${parsing.columnNumber}`
-                            }], { prefixSpaceLength: 4 });
-                        }
-                    }
-                }
-                break;
-            default:
-                break;
-        }
-
-        // logSummary(logger, {
-        //     waring: [`${result.localizations
-        //         ?.filter((x) => x.parsings.filter((y) => y.isStatic)).map((localization) => Object.entries(localization.extraction.changes).length)
-        //         .reduce((a, b) => a + b, 0)} static strings detected`, true],
-        //     success: [`${result.localizations?.length} files analyzed`, true]
-        // }, { prefixSpaceLength: 4 });
-
-        logSeparator(logger);
-
-        return Promise.resolve();
-    }
-
-    function validateOptions(options: ILocalizatorTaskOptions): void {
-        if (!options.cwd) {
-            throw new Error('No cwd provided.');
-        }
-
-        if (!['sort', 'analyze', 'transform', 'generate', 'detect'].includes(options.mode)) {
-            throw new Error('Invalid mode provided.');
-        }
-    }
-
-    function extractOptionsFromMode(options: ILocalizatorTaskOptions): ILocalizatorTaskOptions {
-        const commonOptions: ILocalizatorTaskOptions = {
-            ...options,
-            actions: {
-                analyze: {},
-                sort: {},
-                transform: {},
-                generate: {},
-                // TODO: why is this different? NOW We know it!
-                // the detect action properties are part of different other actions.
-                // for example 'resourceRoot'. We have to move the properties directly to the root.
-                detect: options.actions.detect
-            }
-        };
-
-        switch (options.mode) {
-            case 'sort':
-                return {
-                    ...commonOptions,
-                    actions: {
-                        sort: options.actions.sort,
-                        detect: options.actions.detect
-                    }
-                };
-            case 'analyze':
-                return {
-                    ...commonOptions,
-                    actions: {
-                        analyze: options.actions.analyze,
-                        detect: options.actions.detect
-                    }
-                };
-            case 'transform':
-                return {
-                    ...commonOptions,
-                    actions: {
-                        transform: options.actions.transform,
-                        detect: options.actions.detect
-                    }
-                };
-            case 'generate':
-                return {
-                    ...commonOptions,
-                    actions: {
-                        generate: options.actions.generate,
-                        detect: options.actions.detect
-                    }
-                };
-            case 'detect':
-                return {
-                    ...commonOptions,
-                    actions: {
-                        detect: options.actions.detect,
-                        analyze: options.actions.analyze
-                    }
-                };
-            default:
-                throw new Error('Invalid mode provided.');
-        }
-    }
-
-}