@breadstone-infrastructure/nx-tasks 0.0.256 → 0.0.258

package/src/executors/icon-collection-builder/executor.task.ts

@@ -0,0 +1,284 @@
+// #region Imports
+
+import { ConsoleLogger, File, type ILogger, logSeparator, Path, yellow } from '@breadstone-infrastructure/utilities';
+import fs from 'fs';
+import path from 'path';
+import { type INormalizedSvgResult, svgToNormalizedSinglePath, svgToSinglePath } from './svg';
+
+// #endregion
+
+export namespace IconCollectionBuilderTask {
+
+    interface SVGElement {
+        name: string
+        type: string
+        value: string
+        attributes: Record<string, string>
+        children: SVGElement[]
+    }
+
+    interface SVGData {
+        name: string;
+        category: string;
+        componentName: string;
+        data: string;
+        originalSize: number | null;
+    }
+
+    type SVGDataPaths = Array<SVGData>;
+
+    interface ISetConfig {
+        name: string;
+        cwd: string;
+        inDir: string;
+        outDir: string;
+        targetViewBox?: number;
+        types: Array<{
+            key: string;
+            pattern: string;
+            outputFile: string;
+            nameTransform?: {
+                removePrefix?: string;
+                removeSuffix?: string;
+                removePattern?: string;
+            };
+        }>;
+    }
+
+    export interface IIconCollectionBuilderTaskOptions {
+        sets: Array<ISetConfig>;
+    }
+
+    export async function run(options: IIconCollectionBuilderTaskOptions): Promise<void> {
+        const logger = new ConsoleLogger();
+
+        logSeparator(logger, 'Build icons');
+
+        for (const set of options.sets) {
+            logger.log(`📦 Processing icon set [${set.name}]`);
+
+            try {
+                const basePath = Path.combine(set.cwd, set.inDir);
+
+                for (const typeConfig of set.types) {
+                    logger.log(`  🔍 Type [${typeConfig.key}] with pattern [${typeConfig.pattern}]`);
+
+                    const globPattern = Path.combine(basePath, typeConfig.pattern);
+                    const files = File.glob(globPattern);
+                    logger.log(`  📄 Found [${files.length}] files`);
+
+                    let normalizedCount = 0;
+                    let alreadyTargetCount = 0;
+                    const svgDataMap = new Map<string, SVGData>();
+                    let duplicateCount = 0;
+
+                    for (const svgFilePath of files) {
+                        // eslint-disable-next-line no-await-in-loop
+                        const result = await extractSVGDataPath(svgFilePath, set.targetViewBox, logger);
+
+                        // eslint-disable-next-line max-depth
+                        if (!result) {
+                            logger.warn(`  ⚠️  Skipping [${path.basename(svgFilePath)}] - no path data found`);
+                            continue;
+                        }
+
+                        // eslint-disable-next-line max-depth
+                        if (result.wasNormalized) {
+                            normalizedCount++;
+                        } else {
+                            alreadyTargetCount++;
+                        }
+
+                        // Get raw filename without extension
+                        const rawFileName = path.basename(svgFilePath, '.svg');
+
+                        // Apply transformations
+                        const transformedName = transformIconName(rawFileName, typeConfig.nameTransform);
+
+                        // Convert to camelCase and PascalCase
+                        const camelCaseName = toCamelCase(transformedName);
+                        const pascalCaseName = toPascalCase(transformedName);
+
+                        const originalSize = parseOriginalSize(result.sourceViewBox);
+
+                        const entry: SVGData = {
+                            name: camelCaseName,
+                            category: path.basename(path.dirname(svgFilePath)),
+                            componentName: pascalCaseName,
+                            data: result.pathData,
+                            originalSize
+                        };
+
+                        const existing = svgDataMap.get(camelCaseName);
+
+                        // eslint-disable-next-line max-depth
+                        if (existing) {
+                            duplicateCount++;
+
+                            // eslint-disable-next-line max-depth
+                            if (typeof set.targetViewBox === 'number') {
+                                const existingDistance = typeof existing.originalSize === 'number'
+                                    ? Math.abs(existing.originalSize - set.targetViewBox)
+                                    : Infinity;
+                                const newDistance = typeof originalSize === 'number'
+                                    ? Math.abs(originalSize - set.targetViewBox)
+                                    : Infinity;
+
+                                // eslint-disable-next-line max-depth
+                                if (newDistance < existingDistance) {
+                                    svgDataMap.set(camelCaseName, entry);
+                                }
+                            }
+                        } else {
+                            svgDataMap.set(camelCaseName, entry);
+                        }
+                    }
+
+                    const svgDataPaths = [...svgDataMap.values()];
+
+                    if (duplicateCount > 0) {
+                        logger.log(yellow(`  [!] ${duplicateCount} duplicate icons resolved by best-fit variant`));
+                    }
+
+                    if (set.targetViewBox) {
+                        logger.log(`  📐 Normalization (target: ${set.targetViewBox}x${set.targetViewBox}): ${alreadyTargetCount} already correct, ${normalizedCount} normalized`);
+
+                        if (normalizedCount > 0) {
+                            logger.log(yellow(`  [!] ${normalizedCount} icons were rescaled to ${set.targetViewBox}x${set.targetViewBox}`));
+                        }
+                    }
+
+                    if (svgDataPaths.length === 0) {
+                        logger.warn(`  ⚠️  No valid SVG files found for [${typeConfig.key}]`);
+                        continue;
+                    }
+
+                    // Ensure output directory exists
+                    const outPath = Path.combine(set.cwd, set.outDir);
+                    if (!fs.existsSync(outPath)) {
+                        fs.mkdirSync(outPath, { recursive: true });
+                    }
+
+                    // Write JSON file
+                    const outFilePath = Path.combine(outPath, typeConfig.outputFile);
+                    File.writeAllText(outFilePath, JSON.stringify(svgDataPaths, null, 4));
+
+                    logger.log(`  ✅ Processed [${svgDataPaths.length}] unique icons → [${typeConfig.outputFile}]`);
+                }
+            } catch (error) {
+                logger.error(`❌ Error processing set [${set.name}]:`, error);
+            }
+        }
+
+        logSeparator(logger);
+
+        return Promise.resolve();
+    }
+
+    /**
+     * Transform icon name based on configuration
+     * @param fileName - Raw filename without extension
+     * @param transform - Transformation rules
+     * @returns Transformed filename
+     */
+    function transformIconName(fileName: string, transform?: ISetConfig['types'][0]['nameTransform']): string {
+        if (!transform) {
+            return fileName;
+        }
+
+        let name = fileName;
+
+        // Remove prefix
+        if (transform.removePrefix) {
+            const escapedPrefix = escapeRegex(transform.removePrefix);
+            name = name.replace(new RegExp(`^${escapedPrefix}`), '');
+        }
+
+        // Remove suffix
+        if (transform.removeSuffix) {
+            const escapedSuffix = escapeRegex(transform.removeSuffix);
+            name = name.replace(new RegExp(`${escapedSuffix}$`), '');
+        }
+
+        // Remove custom pattern (supports regex)
+        if (transform.removePattern) {
+            name = name.replace(new RegExp(transform.removePattern, 'g'), '');
+        }
+
+        return name;
+    }
+
+    /**
+     * Escape regex special characters for safe string matching
+     * @param str - String to escape
+     * @returns Escaped string
+     */
+    function escapeRegex(str: string): string {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    /**
+     * Convert kebab-case or snake_case to camelCase
+     * @param str - Input string
+     * @returns camelCase string
+     */
+    function toCamelCase(str: string): string {
+        return str
+            .split(/[-_]/)
+            .map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+    }
+
+    /**
+     * Convert kebab-case or snake_case to PascalCase
+     * @param str - Input string
+     * @returns PascalCase string
+     */
+    function toPascalCase(str: string): string {
+        const camel = toCamelCase(str);
+        return camel.charAt(0).toUpperCase() + camel.slice(1);
+    }
+
+    /**
+     * Parses the original size from a viewBox string
+     * @param sourceViewBox - The source viewBox string (e.g. "0 0 20 20")
+     * @returns The size as a number or null if not parseable
+     */
+    function parseOriginalSize(sourceViewBox: string): number | null {
+        const parts = sourceViewBox.split(/[\s,]+/).map(Number);
+
+        if (parts.length === 4 && !parts.some(isNaN)) {
+            return Math.max(parts[2], parts[3]);
+        }
+
+        return null;
+    }
+
+    /**
+     * Extract path data from SVG file
+     * @param svgFilePath - Path to SVG file
+     * @param logger - Logger instance
+     * @returns Combined path data or null if none found
+     */
+    async function extractSVGDataPath(svgFilePath: string, targetViewBox: number | undefined, logger: ILogger): Promise<INormalizedSvgResult | null> {
+        try {
+            const svgContent = File.readAllText(svgFilePath, 'utf-8');
+
+            if (typeof targetViewBox === 'number') {
+                return await svgToNormalizedSinglePath(svgContent, targetViewBox);
+            }
+
+            const pathData = await svgToSinglePath(svgContent);
+
+            return {
+                pathData,
+                sourceViewBox: 'unknown',
+                wasNormalized: false
+            };
+        } catch (error) {
+            logger.error(`  ❌ Error parsing SVG [${path.basename(svgFilePath)}]:`, error);
+            return null;
+        }
+    }
+
+}

package/src/executors/icon-collection-builder/executor.ts

@@ -0,0 +1,67 @@
+
+// #region Imports
+
+import type { ExecutorContext } from '@nx/devkit';
+import { getProjectRoot } from '../../utils/getProjectRoot';
+import type { IconCollectionBuilderExecutorOptions } from './executor.options';
+
+// #endregion
+
+/**
+ * @public
+ */
+export default async function runExecutor(options: IconCollectionBuilderExecutorOptions, context: ExecutorContext): Promise<{ success: boolean }> {
+    try {
+        const task = (await import('./executor.task')).IconCollectionBuilderTask;
+
+        await task.run({
+            sets: [
+                {
+                    cwd: getProjectRoot(context),
+                    name: 'fluent',
+                    inDir: 'static/icons/fluent/',
+                    outDir: 'static/icons/',
+                    targetViewBox: 24,
+                    types: [
+                        {
+                            key: 'filled',
+                            pattern: '**/*_filled.svg',
+                            outputFile: 'fluent-filled.json',
+                            nameTransform: {
+                                removePrefix: 'ic_fluent_',
+                                removePattern: '_\\d+_filled$'
+                            }
+                        },
+                        {
+                            key: 'regular',
+                            pattern: '**/*_regular.svg',
+                            outputFile: 'fluent-outlined.json',
+                            nameTransform: {
+                                removePrefix: 'ic_fluent_',
+                                removePattern: '_\\d+_regular$'
+                            }
+                        }
+                    ]
+                },
+                {
+                    cwd: getProjectRoot(context),
+                    name: 'lucide',
+                    inDir: 'static/icons/lucide/',
+                    outDir: 'static/icons/',
+                    types: [
+                        {
+                            key: 'default',
+                            pattern: '**/*.svg',
+                            outputFile: 'lucide-outlined.json'
+                        }
+                    ]
+                }
+                // ...options.sets
+            ]
+        });
+        return { success: true };
+    } catch (error) {
+        console.error(error);
+        return { success: false };
+    }
+}

package/src/executors/icon-collection-builder/schema.json

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