@breadstone-infrastructure/nx-tasks 0.0.258 → 0.0.260

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

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

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

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