@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

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

@@ -0,0 +1,433 @@
+/* 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

@@ -0,0 +1,47 @@
+// #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

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

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

@@ -0,0 +1,11 @@
+// #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

@@ -0,0 +1,194 @@
+/* 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.');
+        }
+    }
+
+}