@breadstone-infrastructure/nx-tasks 0.0.257 → 0.0.258

package/src/executors/localizator/executor.ts

@@ -0,0 +1,45 @@
+// #region Imports
+
+import { Path } from '@breadstone-infrastructure/utilities';
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import { isVerbose } from '../../utils/isVerbose';
+import type { LocalizatorExecutorOptions } from './executor.options';
+
+// #endregion
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: LocalizatorExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).LocalizatorTask;
+
+        await task.run({
+            mode: options.mode,
+            cwd: getProjectRoot(context),
+            dryRun: options.dryRun,
+            verbose: isVerbose(context, options),
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            },
+            callback: options.callback,
+            envFile: options.envFile,
+            env: options.env,
+            actions: {
+                detect: options.actions.detect,
+                analyze: options.actions.analyze,
+                transform: {
+                    types: options.actions.transform?.types ?? ['json']
+                },
+                sort: options.actions.sort,
+                generate: options.actions.generate
+            }
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/localizator/schema.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "textToEcho": {
+      "type": "string",
+      "description": "Text To Echo"
+    }
+  }
+}

package/src/executors/markdown-to-typescript-transform/MarkdownRenderer.ts

@@ -0,0 +1,96 @@
+// #region Imports
+
+import type { Renderer, Tokens } from 'marked';
+
+// #endregion
+
+export type MarkdownRenderer = Partial<Omit<Renderer, 'options' | 'constructor'>>;
+export type MarkdownRendererOptions = {
+    wrapText: boolean;
+} & { [key in keyof Partial<Omit<Renderer, 'options' | 'constructor'>>]: {
+    class?: string;
+    style?: string;
+} };
+
+/**
+ * Creates a marked.js renderer that outputs custom components
+ *
+ * @public
+ */
+export function createMarkedRenderer(options?: MarkdownRendererOptions): MarkdownRenderer {
+    options = {
+        wrapText: true,
+        ...options
+    };
+
+    return {
+        heading: (token) => `
+            <h${token.depth} style="font: var(--theme-headline${token.depth}-typography); letter-spacing: var(--theme-headline${token.depth}-typography-letter-spacing);">
+                ${token.text}
+            </h${token.depth}>`,
+        hr: () => '<mosaik-divider></mosaik-divider>',
+        table: (token) => `
+            <mosaik-table>
+                <mosaik-table-header>
+                    ${token.header}
+                </mosaik-table-header>
+                <mosaik-table-body>
+                    ${token.rows}
+                </<mosaik-table-body>
+            </mosaik-table>`,
+        tablerow: (token) => `
+            <mosaik-table-row>
+                ${token.text}
+            </mosaik-table-row>`,
+        tablecell: (token) => `
+            <mosaik-table-cell align="${token.align}">
+                ${token.text}
+            </mosaik-table-cell>`,
+        text: (text) => `
+            <mosaik-text wrap="${options.wrapText}" text="${text}">
+                <p part="text">${text}</p>
+            </mosaik-text>`,
+        link: (token): string => {
+            const cleanHref = cleanUrl(token.href);
+            if (cleanHref === null) {
+                return token.text;
+            }
+            token.href = cleanHref;
+            let out = `<mosaik-anchor href="${token.href}"`;
+            if (token.title) {
+                out += ` title="${token.title}"`;
+            }
+            if (token.text) {
+                out += ` label="${token.text}"`;
+            }
+            out += '></mosaik-anchor>';
+            return out;
+        },
+        list(token: Tokens.List): string {
+            const type = token.ordered ? 'ordered' : 'unordered';
+            let body = '';
+            for (const item of token.items) {
+                body += this.listitem!(item);
+            }
+
+            return `<mosaik-listing type="${type}"${token.ordered && token.start !== 1 ? ` start="${token.start}"` : ''}>${body}</mosaik-listing>`;
+        },
+        listitem(item: Tokens.ListItem): string {
+            return `<mosaik-listing-item>${item.text}</mosaik-listing-item>`;
+        }
+    };
+}
+
+function cleanUrl(href: string): string | null {
+    try {
+        href = encodeURI(href).replace(/%25/g, '%');
+    } catch (e) {
+        return null;
+    }
+
+    return href;
+}
+
+export namespace MarkdownRenderer {
+    export const DEFAULT = createMarkedRenderer();
+}

package/src/executors/markdown-to-typescript-transform/executor.task.ts

@@ -0,0 +1,113 @@
+// #region Imports
+
+import { ConsoleLogger, File, gray, type IFileCacheOptions, logPair, logSeparator, magenta, Path, Template } from '@breadstone-infrastructure/utilities';
+import prettier from 'prettier';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+import { withCaching } from '../../utils/withCaching';
+
+// #endregion
+
+/**
+ * @description Task to generate ts from markdown docs.
+ * @public
+ */
+export namespace MarkdownToTypescriptTransformTask {
+
+    export const DEFAULT_OPTIONS = {
+        templateFile: '.build/templates/DocTransform.ts.tpl',
+        ignore: ['index', 'app'],
+        verbose: false
+    };
+
+    export interface IMarkdownToTypescriptTransformTaskOptions {
+        cwd: string;
+        path: string;
+        packageJson: PackageJson;
+        tsConfigJson: TsConfigJson;
+        templateFile: string;
+        ignore: Array<string>;
+        verbose?: boolean;
+        cache?: IFileCacheOptions;
+    }
+
+    export async function run(options: IMarkdownToTypescriptTransformTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+        logSeparator(logger, 'Transforming docs');
+
+        const fileCache = withCaching(options.cache);
+
+        // quickfix for txt files
+        File.glob(Path.combine(options.cwd, options.path, '**/*.txt')).forEach((x) => {
+            File.move(x, Path.changeExtension(x, '.json'));
+        });
+
+        const filesPath = Path.combine(options.cwd, options.path, '**/*.json');
+        const files = File.glob(filesPath);
+        let hasChanges = false;
+
+        if (options.verbose) {
+            logger.log(gray(`search in: ${filesPath}`));
+        }
+
+        if (files.length) {
+            if (options.verbose) {
+                logger.log(gray(`${files.length} files to transform`));
+            }
+
+            for (const x of files) {
+                // eslint-disable-next-line no-await-in-loop
+                if (!await fileCache.isFileCached(x)) {
+                    hasChanges = true;
+
+                    const fileName = Path.getFileName(x);
+                    const outName = Path.changeExtension(x, '.ts');
+
+                    logPair(logger, magenta(`from: '${Path.relative(options.cwd, x)}'`), magenta(`to: '${Path.relative(options.cwd, outName)}'`), {
+                        prefixSpaceLength: 2
+                    });
+
+                    try {
+                        // const renderer = createMarkedRenderer({ wrapText: true });
+                        // marked.use({ renderer });
+                        // const renderResult = marked(File.readAllText(x)) as string;
+                        const renderResult = File.readAllText(x);
+                        const tplPath = Path.combine(options.cwd, options.templateFile);
+                        const templateContent = File.readAllText(tplPath);
+                        // const formatResult = await formatHtml(renderResult.toString());
+                        const tpl = Template.create({
+                            // TODO: add replaceFn here from options
+                            name: Path.getFileNameWithoutExtension(fileName).replace('mosaik-', ''),
+                            content: renderResult
+                        }, { unescapeContent: true }).apply(templateContent)
+                            .toString();
+
+                        File.writeAllText(outName, tpl);
+                    } catch (error) {
+                        logger.error(`Error while transpiling '${fileName}'.`);
+                        logger.error(`${error.message} in ${error.file} at ${error.line},${error.column}`);
+
+                        File.writeAllText(outName, 'ERROR');
+                        process.exit(-1);
+                    }
+                } else if (options.verbose) {
+                    logger.log(gray(` File ${Path.relative(options.cwd, x)} is up to date.`));
+                }
+            }
+
+            if (!hasChanges) {
+                logger.log(gray('  Everything is up to date.'));
+            }
+        } else {
+            logger.log(gray('\tFile or Folder is up to date.'));
+        }
+
+        logSeparator(logger);
+
+        return Promise.resolve();
+    }
+
+    function formatHtml(html: string): Promise<string> {
+        return prettier.format(html, { parser: 'html' });
+    }
+
+}

package/src/executors/markdown-to-typescript-transform/executor.ts

@@ -0,0 +1,44 @@
+
+// #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 { MarkdownToTypescriptTransformTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @private
+ */
+type ExecutorOptions = Omit<MarkdownToTypescriptTransformTask.IMarkdownToTypescriptTransformTaskOptions, 'cwd' | 'packageJson' | 'tsConfigJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: ExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).MarkdownToTypescriptTransformTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            ignore: options.ignore,
+            templateFile: options.templateFile,
+            path: options.path,
+            verbose: isVerbose(context, options),
+            cache: {
+                enabled: options.cache?.enabled ?? context.target?.cache ?? false,
+                dirPath: Path.combine(getProjectRoot(context), '.cache')
+            }
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/markdown-to-typescript-transform/schema.json

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

package/src/executors/ng-api-extractor/executor.options.ts

@@ -0,0 +1,10 @@
+// #region Imports
+
+import type { NgApiExtractorTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type NgApiExtractorExecutorOptions = Omit<NgApiExtractorTask.INgApiExtractorTaskOptions, 'cwd' | 'tsConfigPath'>;

package/src/executors/ng-api-extractor/executor.task.ts

@@ -0,0 +1,157 @@
+// #region Imports
+
+import { createCompilerHost, type DirectiveEntry, type DocEntry, EntryType, type MemberEntry, MemberTags, MemberType, type NgtscProgram, performCompilation, type PropertyEntry, readConfiguration } from '@angular/compiler-cli';
+import { writeFileSync } from 'fs';
+import { ensureDirSync } from 'fs-extra';
+import * as path from 'path';
+import * as ts from 'typescript';
+import { ConsoleLogger, logSeparator } from '@breadstone-infrastructure/utilities';
+
+// #endregion
+
+/**
+ * @description Task to build angular projects with ng-packagr
+ * @public
+ */
+export namespace NgApiExtractorTask {
+
+    export interface INgApiExtractorTaskOptions {
+        cwd: string;
+        outputPath: string;
+        tsConfigPath: string
+    }
+
+    interface DirectiveDefinition {
+        name: string;
+        selector: string;
+        description?: string;
+        exportAs: Array<string>;
+        inputs?: Array<InputDefinition>;
+        outputs?: Array<OutputDefinition>;
+    }
+
+    interface InputDefinition {
+        name: string;
+        type: string;
+        description: string;
+        isRequired: boolean;
+        defaultValue?: string;
+    }
+
+    interface OutputDefinition {
+        name: string;
+        type: string;
+        description: string;
+    }
+
+    export async function run(options: INgApiExtractorTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+        logSeparator(logger, 'Ng Api Extractor');
+
+        const outputPath = options.outputPath;
+        // Resolve output path relative to workspace root
+        const workspaceRoot = options.cwd;
+        const resolvedOutputPath = path.resolve(workspaceRoot, outputPath);
+        const tsConfigPath = ts.findConfigFile('packages/ng-primitives', ts.sys.fileExists, 'tsconfig.lib.json');
+        const { options: compilerOptions, rootNames } = readConfiguration(options.tsConfigPath);
+        const host = createCompilerHost({ options: compilerOptions });
+        const compilation = performCompilation({
+            options: compilerOptions,
+            rootNames,
+            host
+        });
+        const program = compilation.program as NgtscProgram;
+        const directives: Record<string, DirectiveDefinition> = {};
+
+        for (const entrypoint of rootNames) {
+            try {
+                const api = program.getApiDocumentation(entrypoint, new Set<string>());
+
+                for (const directive of api.entries) {
+                    if (!isDirective(directive)) {
+                        continue;
+                    }
+
+                    directives[directive.name] = {
+                        name: directive.name,
+                        description: directive.description,
+                        selector: directive.selector,
+                        exportAs: directive.exportAs,
+                        inputs: directive.members.filter(isInput).map(mapToInputDefinition),
+                        outputs: directive.members?.filter(isOutput).map(mapToOutputDefinition)
+                    };
+                }
+            } catch (e) {
+                logger.error(`Error processing entrypoint ${entrypoint}: ${e}`);
+                continue;
+            }
+        }
+
+        // Ensure the output directory exists
+        const outputDir = resolvedOutputPath.substring(0, resolvedOutputPath.lastIndexOf('/'));
+        ensureDirSync(outputDir);
+
+        writeFileSync(resolvedOutputPath, JSON.stringify(directives, null, 2));
+
+        logger.info(`API data written to: ${resolvedOutputPath}`);
+
+        logger.info('API extraction completed successfully.');
+    }
+
+    function isDirective(entry: DocEntry): entry is DirectiveEntry {
+        return entry.entryType === EntryType.Directive;
+    }
+
+    function isProperty(entry: MemberEntry): entry is PropertyEntry {
+        return entry.memberType === MemberType.Property;
+    }
+
+    function isInput(entry: MemberEntry): entry is PropertyEntry {
+        // the following inputs we want to skip as they are just HTML attributes
+        const inputsToSkip = ['id'];
+
+        return (isProperty(entry) && entry.memberTags.includes(MemberTags.Input) && !inputsToSkip.includes(entry.inputAlias ?? ''));
+    }
+
+    function isOutput(entry: MemberEntry): entry is PropertyEntry {
+        return isProperty(entry) && entry.memberTags.includes(MemberTags.Output);
+    }
+
+    function mapToInputDefinition(entry: PropertyEntry): InputDefinition {
+        const safeName = entry.inputAlias ?? '###TODO-MISSING-ALIAS###';
+
+        return {
+            name: safeName,
+            // Extract the type parameter, handling nested generics and function types with commas
+            type: (() => {
+                const match = (/^(InputSignal|InputSignalWithTransform|ModelSignal)<(.+)>$/).exec(entry.type);
+                if (!match) { return entry.type; }
+                const typeParam = match[2];
+                // For InputSignalWithTransform<T, U>, only extract T (but avoid splitting inside parens)
+                // Find the first comma not inside parentheses
+                let depth = 0;
+                for (let i = 0; i < typeParam.length; i++) {
+                    if (typeParam[i] === '(') { depth++; } else if (typeParam[i] === ')') { depth--; } else if (typeParam[i] === ',' && depth === 0) {
+                        return typeParam.slice(0, i).trim();
+                    }
+                }
+                return typeParam.trim();
+            })(),
+            description: entry.description,
+            isRequired: entry.isRequiredInput || entry.jsdocTags.some((tag) => tag.name === 'required'),
+            defaultValue: entry.jsdocTags.find((tag) => tag.name === 'default')?.comment
+        };
+    }
+
+    function mapToOutputDefinition(entry: PropertyEntry): OutputDefinition {
+        const safeName = entry.outputAlias ?? '###TODO-MISSING-ALIAS###';
+
+        return {
+            name: entry.type.includes('ModelSignal') ? `${safeName}Change` : safeName,
+            // the type will be OutputEmitterRef<T> or ModelSignal<T>, we want to extract the T
+            type: entry.type.replace(/^(OutputEmitterRef|ModelSignal)<(.*)>$/, '$2'),
+            description: entry.description
+        };
+    }
+
+}

package/src/executors/ng-api-extractor/executor.ts

@@ -0,0 +1,27 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import type { NgApiExtractorExecutorOptions } from './executor.options';
+import { getProjectTsConfigPath } from '../../utils/getProjectTsConfigJson';
+
+// #endregion
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: NgApiExtractorExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).NgApiExtractorTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            outputPath: options.outputPath,
+            tsConfigPath: getProjectTsConfigPath(context)
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/ng-api-extractor/schema.json

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

package/src/executors/ng-packagr-build/executor.task.ts

@@ -0,0 +1,49 @@
+// #region Imports
+
+import { ConsoleLogger, logSeparator, Path } from '@breadstone-infrastructure/utilities';
+import { ngPackagr } from 'ng-packagr';
+
+// #endregion
+
+/**
+ * @description Task to build angular projects with ng-packagr
+ * @public
+ */
+export namespace NgPackagrBuildTask {
+
+    export interface INgPackagrBuildTaskOptions {
+        cwd: string;
+    }
+
+    export async function run(options: INgPackagrBuildTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Ng Packagr Build');
+
+        try {
+            await ngPackagr()
+                .forProject(Path.combine(options.cwd, 'ng-package.json'))
+                .withTsConfig(Path.combine(options.cwd, 'tsconfig.json'))
+                .build();
+        } catch (error) {
+            logger.error('Error while building the project with ng-packagr');
+            logger.error(error);
+            process.exit(1);
+        }
+
+        logSeparator(logger);
+        // .then(() => {
+        //     File.delete(Path.combine(options.cwd, 'dist', 'package.json'));
+
+        //     // Validate the output.
+        //     // Sometimes it happens that the __ivy_ngcc__ files are not deleted.
+        //     // If this occurs the compilation is faulty.
+        //     if (Directory.exists(Path.combine(options.cwd, '__ivy_ngcc__'))) {
+        //         Directory.delete(Path.combine(options.cwd, '__ivy_ngcc__'));
+        //         logger.error('The __ivy_ngcc__ files were not removed correctly. Please clean up and create the project again.');
+        //         // Throw new Error('The __ivy_ngcc__ files were not removed correctly. Please clean up and create the project again.');
+        //     }
+        // })
+    }
+
+}

package/src/executors/ng-packagr-build/executor.ts

@@ -0,0 +1,29 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import type { NgPackagrBuildTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type NgPackagrBuildExecutorOptions = Omit<NgPackagrBuildTask.INgPackagrBuildTaskOptions, 'cwd' | 'tsConfigJson' | 'packageJson' | 'verbose'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: NgPackagrBuildExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).NgPackagrBuildTask;
+
+        await task.run({
+            cwd: getProjectRoot(context)
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/ng-packagr-build/schema.json

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