@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

package/src/executors/vue-proxy-transform/executor.task.ts

@@ -0,0 +1,226 @@
+// #region Imports
+
+import { blue, ConsoleLogger, CustomElementManifest, File, gray, green, type IFileCacheOptions, logSeparator, Path } from '@breadstone-infrastructure/utilities';
+import prettier from 'prettier';
+import type { PackageJson, TsConfigJson } from 'type-fest';
+import { withCaching } from '../../utils/withCaching';
+
+// #endregion
+
+export namespace VueProxyTransformTask {
+
+    export const DEFAULT_OPTIONS = {
+        verbose: false,
+        cleanOut: false,
+        aliases: {},
+        ignore: [],
+        prettier: {
+            arrowParens: 'always',
+            bracketSameLine: false,
+            bracketSpacing: true,
+            semi: true,
+            experimentalTernaries: true,
+            singleQuote: true,
+            jsxSingleQuote: false,
+            quoteProps: 'as-needed',
+            trailingComma: 'none',
+            singleAttributePerLine: false,
+            proseWrap: 'never',
+            insertPragma: false,
+            requirePragma: false,
+            tabWidth: 4,
+            useTabs: false,
+            embeddedLanguageFormatting: 'auto',
+            printWidth: 1200
+        } satisfies prettier.Config
+    };
+
+    export interface IVueProxyTransformOptions {
+        cwd: string;
+        path: string;
+        out: string;
+        cleanOut?: boolean;
+        packageJson: PackageJson;
+        tsConfigJson: TsConfigJson;
+        verbose?: boolean;
+        aliases?: Record<string, string>;
+        ignore?: Array<string>;
+        cache?: IFileCacheOptions;
+    }
+
+    export async function run(options: IVueProxyTransformOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Vue Proxy Transform');
+
+        const fileCache = withCaching(options.cache);
+
+        // TODO: remove this when wca is not longer used.
+        // this happen when json2 is used as format; afterwards text files will be created.
+        // we have to change the extension to again to json
+        const textFiles = File.glob(Path.combine(options.cwd, options.path, '**/*.txt'));
+        textFiles.forEach((file) => {
+            const content = File.readAllText(file);
+            File.writeAllText(file.replace('.txt', '.json'), content);
+            File.delete(file);
+        });
+
+        const filesPath = Path.combine(options.cwd, options.path, '**/*.json');
+        const files = File.glob(filesPath);
+        const createdFiles: Array<string> = [];
+
+        if (options.verbose) {
+            logger.log(gray(`    Search for: ${filesPath}`));
+        }
+
+        if (files.length) {
+            if (options.verbose) {
+                logger.log(gray(`    ${files.length} files to transform`));
+            }
+
+            for (const file of files) {
+                // eslint-disable-next-line no-await-in-loop
+                if (!await fileCache.isFileCached(file)) {
+                    try {
+                        const doc = File.readAllJson(file) as unknown as CustomElementManifest.PackageDoc;
+                        const def = CustomElementManifest.readDefinition(doc);
+                        const properties = CustomElementManifest.readProperties(doc);
+                        const methods = CustomElementManifest.readMethods(doc);
+                        const events = CustomElementManifest.readEvents(doc);
+                        const slots = CustomElementManifest.readSlots(doc);
+                        const out = getOutPathAndFile(def.declaration.module ?? '');
+
+                        // eslint-disable-next-line max-depth
+                        if (options.ignore?.includes(def.name)) {
+                            // eslint-disable-next-line max-depth
+                            if (options.verbose) {
+                                logger.log(gray(`    [IGNORE] ${Path.relative(options.cwd, file)}`));
+                            }
+                            continue;
+                        }
+
+                        const rootDir = options.tsConfigJson.compilerOptions?.rootDir ?? '';
+                        const outPath = Path.combine(options.cwd, options.out, out ?? '');
+                        const utilsPath = Path.combine(options.cwd, 'src/utils/Proxy.ts');
+                        const relativeUtilsPath = Path.relative(Path.getDirectoryName(outPath), utilsPath);
+
+                        Path.relative(options.cwd, rootDir);
+                        let result = createVueComponentDefinition(relativeUtilsPath, def.name, properties.map((x) => x.name), events.map((x) => x.name), methods.map((x) => x.name), slots.map((x) => x.name), options.aliases ?? {});
+                        // eslint-disable-next-line no-await-in-loop
+                        result = await formatTypeScript(result);
+                        const outFileExists = File.exists(outPath);
+
+                        File.writeAllText(outPath, result);
+                        createdFiles.push(Path.relative(options.cwd, outPath));
+
+                        // eslint-disable-next-line max-depth
+                        if (outFileExists) {
+                            logger.log(`    ${blue('[UPDATE]')} ${out}`);
+                        } else {
+                            logger.log(`    ${green('[CREATE]')} ${out}`);
+                        }
+                    } catch (error) {
+                        logger.error('    Error while transforming.');
+                        logger.error(`    ${error}`);
+                    }
+                } else if (options.verbose) {
+                    logger.log(gray(`    File ${Path.relative(options.cwd, file)} is up to date.`));
+                }
+            }
+
+            try {
+                const indexExports = createIndexExports(createdFiles);
+                const outPath = Path.combine(options.cwd, options.out, 'Index.ts');
+                const formatted = await formatTypeScript(indexExports);
+                File.writeAllText(outPath, formatted);
+                logger.log(`    ${blue('[CREATE]')} Index.ts`);
+            } catch (error) {
+                logger.error('Error while transforming.');
+                logger.error(`${error}`);
+            }
+        } else {
+            logger.log(gray('\tFile or Folder is up to date.'));
+        }
+
+        logSeparator(logger);
+
+        return Promise.resolve();
+    }
+
+    function formatTypeScript(code: string): Promise<string> {
+        return prettier.format(code, {
+            parser: 'typescript',
+            ...DEFAULT_OPTIONS.prettier
+        });
+    }
+
+    function createVueComponentDefinition(rootPath: string, tagName: string, inputs: Array<string>, outputs: Array<string>, methods: Array<string>, slots: Array<string>, aliases: Record<string, string>): string {
+        const tagNameAsPascal = dashToPascalCase(tagName);
+        const lookupName: string | null = Object.keys(aliases).includes(tagName) ? aliases[tagName] : null;
+        const controlNameWithoutSuffix = lookupName ?? tagNameAsPascal.replace('Mosaik', '');
+
+        // Generate Vue 3 compatible event handlers (onEventName format instead of Vue 2's on: { eventName })
+        const eventHandlers = outputs.map((output) => `on${output.charAt(0).toUpperCase() + output.slice(1)}: (event: Event) => emit('${output}', event)`).join(',\n                    ');
+
+        return `
+// ------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+// </auto-generated>
+// ------------------------------------------------------------------------------
+
+import { defineComponent, h } from 'vue';
+
+/**
+ * Vue 3 component wrapper for the ${tagName} web component.
+ *
+ * @public
+ */
+export const ${tagNameAsPascal.replace('Mosaik', '')}Component = defineComponent({
+    name: '${tagNameAsPascal.replace('Mosaik', '')}Component',
+    ${inputs.length ? `props: ['${inputs.join("', '")}'],` : ''}
+    ${outputs.length ? `emits: ['${outputs.join("', '")}'],` : ''}
+    // slots: ${slots.length ? `['${slots.join("', '")}']` : '[]'}
+    // methods: ${methods.length ? `{ ${methods.join(', ')} }` : '{}'}
+    setup(props, { slots, emit }) {
+        return () => h(
+            '${tagName}',
+            {
+                ...props,
+                ${outputs.length ? `// Vue 3 event handlers (onEventName format)
+                    ${eventHandlers}` : ''}
+            },
+            slots.default ? slots.default() : []
+        );
+    }
+});
+
+declare module 'vue' {
+    export interface GlobalComponents {
+        ${tagNameAsPascal}: typeof ${tagNameAsPascal.replace('Mosaik', '')}Component;
+    }
+}
+`;
+    }
+
+    function createIndexExports(componentTagNames: Array<string>): string {
+        return componentTagNames
+            .map((x) => Path.combine(Path.getDirectoryName(x), Path.getFileNameWithoutExtension(x)))
+            .map((x) => x.split('src/').pop())
+            .map((x) => `export * from './${x}';`)
+            .join('\n');
+    }
+
+    function dashToPascalCase(str: string): string {
+        return str.toLowerCase()
+            .split('-')
+            .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+            .join('');
+    }
+
+    function getOutPathAndFile(original: string): string | undefined {
+        return original.split('/src').pop()
+            ?.replace('Element.ts', 'Component.ts');
+    }
+}

package/src/executors/vue-proxy-transform/executor.ts

@@ -0,0 +1,45 @@
+// #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 { VueProxyTransformTask } from './executor.task';
+
+// #endregion
+
+/**
+ * @public
+ */
+export type VueProxyTransformExecutorOptions = Omit<VueProxyTransformTask.IVueProxyTransformOptions, 'cwd' | 'tsConfigJson' | 'packageJson'>;
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: VueProxyTransformExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).VueProxyTransformTask;
+
+        await task.run({
+            cwd: getProjectRoot(context),
+            packageJson: getProjectPackageJson(context),
+            tsConfigJson: getProjectTsConfigJson(context),
+            out: options.out,
+            path: options.path,
+            verbose: isVerbose(context, options),
+            aliases: options.aliases,
+            cleanOut: options.cleanOut,
+            ignore: options.ignore,
+            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/vue-proxy-transform/schema.json

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

package/src/index.ts

@@ -0,0 +1,31 @@
+export { AliasReplaceTask } from './executors/alias-replace/executor.task';
+export { CleanTask } from './executors/clean/executor.task';
+export { CopyTask } from './executors/copy/executor.task';
+export { DocsTask } from './executors/docs/executor.task';
+export { IconCollectionBuilderTask } from './executors/icon-collection-builder/executor.task';
+export { IconCollectionDownloaderTask } from './executors/icon-collection-downloader/executor.task';
+export { LitDocsTask } from './executors/lit-docs/executor.task';
+export { LitStyleTransformTask } from './executors/lit-style-transform/executor.task';
+export { LocalizatorTask } from './executors/localizator/executor.task';
+export { MarkdownToTypescriptTransformTask } from './executors/markdown-to-typescript-transform/executor.task';
+export { NgApiExtractorTask } from './executors/ng-api-extractor/executor.task';
+export { NgPackagrBuildTask } from './executors/ng-packagr-build/executor.task';
+export { NgProxyTransformTask } from './executors/ng-proxy-transform/executor.task';
+export { ApiGeneratorTask } from './executors/openapi-generator/executor.task';
+export { ReactProxyTransformTask } from './executors/react-proxy-transform/executor.task';
+export { CopyPublisherPackageJsonTask } from './executors/release-package-json/executor.task';
+export { PublishPackageTask } from './executors/release-package/executor.task';
+export { StylesBundleTask } from './executors/scss-style-bundle/executor.task';
+export { SecretsConfigSyncTask } from './executors/secrets-config-sync/executor.task';
+export { SecretsVercelSyncTask } from './executors/secrets-vercel-sync/executor.task';
+export { UnpublishPackageTask } from './executors/unrelease-package/executor.task';
+export { VercelEdgeConfigSyncTask } from './executors/vercel-edge-config-sync/executor.task';
+export { VueProxyTransformTask } from './executors/vue-proxy-transform/executor.task';
+// utils
+export { getProjectPackageJson } from './utils/getProjectPackageJson';
+export { getProjectRoot } from './utils/getProjectRoot';
+export { getProjectTsConfigJson, getProjectTsConfigPath } from './utils/getProjectTsConfigJson';
+export { loadAndExpandDotEnvFile, resolveOptionTree, tryGetEnvVariable } from './utils/loadAndExpandDotEnvFile';
+export type { IEnvOptions } from './utils/loadAndExpandDotEnvFile';
+export { withCaching } from './utils/withCaching';
+

package/src/types/svgpath.d.ts

@@ -0,0 +1,13 @@
+declare module 'svgpath' {
+    interface SvgPath {
+        translate(tx: number, ty: number): SvgPath;
+        scale(sx: number, sy?: number): SvgPath;
+        abs(): SvgPath;
+        round(precision: number): SvgPath;
+        toString(): string;
+    }
+
+    function svgpath(path: string): SvgPath;
+
+    export = svgpath;
+}

package/src/utils/TaskBase.ts

@@ -0,0 +1,42 @@
+// #region Imports
+
+import { ConsoleLogger, type ILogger } from '@breadstone-infrastructure/utilities';
+
+// #endregion
+
+/**
+ * The `TaskBase` class.
+ *
+ * @public
+ */
+export abstract class TaskBase<TRunOptions = Record<string, unknown>> {
+
+    // #region Fields
+
+    private readonly _logger: ILogger;
+
+    // #endregion
+
+    // #region Ctor
+
+    protected constructor() {
+        this._logger = new ConsoleLogger();
+    }
+
+    // #endregion
+
+    // #region Properties
+
+    protected get logger(): ILogger {
+        return this._logger;
+    }
+
+    // #endregion
+
+    // #region Methods
+
+    public abstract run(options: TRunOptions): Promise<void>;
+
+    // #endregion
+
+}

package/src/utils/getProjectPackageJson.ts

@@ -0,0 +1,22 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import type { PackageJson } from 'type-fest';
+import { getProjectRoot } from './getProjectRoot';
+import { Path, File } from '@breadstone-infrastructure/utilities';
+
+// #endregion
+
+/**
+ * @public
+ */
+export function getProjectPackageJson(context: ExecutorContext): PackageJson {
+    const root = getProjectRoot(context);
+    const file = Path.combine(root, 'package.json');
+
+    if (!File.exists(file)) {
+        throw new Error(`The file "${file}" does not exist.`);
+    }
+
+    return File.readAllJson(Path.combine(root, 'package.json')) as PackageJson;
+}

package/src/utils/getProjectRoot.ts

@@ -0,0 +1,14 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { Path } from '@breadstone-infrastructure/utilities';
+
+// #endregion
+
+export function getProjectRoot(context: ExecutorContext): string {
+    const project = context.projectsConfigurations.projects[context.projectName ?? ''];
+
+    return Path.normalize(context.cwd).endsWith(project.root)
+        ? Path.normalize(context.cwd)
+        : Path.combine(Path.normalize(context.cwd), project.root ? Path.normalize(project.root) : '');
+}

package/src/utils/getProjectTsConfigJson.ts

@@ -0,0 +1,29 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import type { TsConfigJson } from 'type-fest';
+import { getProjectRoot } from './getProjectRoot';
+import { Path, File } from '@breadstone-infrastructure/utilities';
+
+// #endregion
+
+/**
+ * @public
+ */
+export function getProjectTsConfigJson(context: ExecutorContext): TsConfigJson {
+    const path = getProjectTsConfigPath(context);
+
+    if (!File.exists(path)) {
+        throw new Error(`The file "${path}" does not exist.`);
+    }
+
+    return File.readAllJson(path) as TsConfigJson;
+}
+
+/**
+ * @public
+ */
+export function getProjectTsConfigPath(context: ExecutorContext): string {
+    const root = getProjectRoot(context);
+    return Path.combine(root, 'tsconfig.json');
+}

package/src/utils/isVerbose.ts

@@ -0,0 +1,24 @@
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+
+// #endregion
+
+/**
+ * Determines whether the execution should be treated as verbose based on the Nx executor context and optional executor options.
+ * The Nx executor context has a built-in `isVerbose` property that indicates if the execution is in verbose mode.
+ * Additionally, an optional `verbose` flag can be provided in the executor options to explicitly request verbose output.
+ * However, the context's verbosity always takes precedence over the options.
+ *
+ * @public
+ * @param context The Nx executor context, which may indicate if the execution is verbose.
+ * @param options An object that may contain an optional `verbose` flag to request verbose output.
+ * @returns A boolean indicating whether the execution should be treated as verbose.
+ */
+export function isVerbose(context: ExecutorContext, options: { verbose?: boolean }): boolean {
+    if (context.isVerbose) {
+        return true;
+    }
+
+    return options.verbose ?? false;
+}

package/src/utils/loadAndExpandDotEnvFile.ts

@@ -0,0 +1,108 @@
+// #region Imports
+
+import { config as loadDotEnvFile } from 'dotenv';
+import { type DotenvExpandOutput, expand } from 'dotenv-expand';
+
+// #endregion
+
+/**
+ * @public
+ */
+export interface IEnvOptions {
+    env: Record<string, string>;
+    envFile?: string;
+}
+
+/**
+ * This function loads a .env file and expands the variables in it.
+ *
+ * @public
+ * @param filename the .env file to load
+ * @param environmentVariables the object to load environment variables into
+ * @param override whether to override existing environment variables
+ */
+export function loadAndExpandDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): DotenvExpandOutput {
+    const env = loadDotEnvFile({
+        path: filename,
+        processEnv: environmentVariables as Record<string, string>,
+        override: override ?? false
+    });
+
+    return expand({
+        ...env,
+        processEnv: environmentVariables as Record<string, string>
+    });
+}
+
+/**
+ * Tries to get an environment variable by its name.
+ * If the variable is not found, it returns the variable name itself.
+ *
+ * @public
+ * @param variableName - The name of the environment variable to retrieve.
+ * @param environmentVariables - The object containing environment variables.
+ * @returns The value of the environment variable or the variable name if not found.
+ */
+export function tryGetEnvVariable(variableName: string, environmentVariables: DotenvExpandOutput): string {
+    const value = environmentVariables.parsed?.[variableName];
+
+    if (value === undefined) {
+        return variableName;
+    }
+
+    return value.trim();
+}
+
+/**
+ * Resolves a string option by replacing any ${VAR_NAME} placeholders with their corresponding environment variable values.
+ * If an environment variable is not found, the placeholder remains unchanged.
+ *
+ * @public
+ * @param input - The string option to resolve.
+ * @param envVars - The object containing environment variables.
+ * @returns The resolved string option.
+ */
+export function resolveOptionTree<T>(input: T, envVars: DotenvExpandOutput): T {
+    if (input === null) {
+        return input;
+    }
+
+    if (typeof input === 'string') {
+        return resolveOption(input, envVars) as unknown as T;
+    }
+
+    if (Array.isArray(input)) {
+        return input.map((item) => resolveOptionTree(item, envVars)) as unknown as T;
+    }
+
+    if (typeof input === 'object') {
+        const output: Record<string, unknown> = {};
+        for (const [key, val] of Object.entries(input)) {
+            output[key] = resolveOptionTree(val, envVars);
+        }
+        return output as T;
+    }
+
+    return input;
+}
+
+/**
+ * @private
+ */
+function resolveOption(raw: string, environmentVariables: DotenvExpandOutput): string {
+    const ENV_RE = /^\{env\.([A-Z0-9_]+)\}$/;
+    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+    const matched = raw.match(ENV_RE);
+    if (matched) {
+        const envVar = matched[1];
+        const v = environmentVariables.parsed?.[envVar];
+
+        if (!v) {
+            throw new Error(`[Environment]: Env var ${envVar} not set.`);
+        }
+
+        return v;
+    }
+
+    return raw;
+}