@gilav21/shadcn-angular 0.0.24 → 0.0.26

package/dist/commands/add.d.ts

@@ -5,7 +5,9 @@ export interface AddOptions {
     all?: boolean;
     path?: string;
     remote?: boolean;
+    dryRun?: boolean;
     branch: string;
+    registry?: string;
 }
 interface ConflictCheckResult {
     toInstall: ComponentName[];

package/dist/commands/add.js

@@ -1,55 +1,17 @@
 import fs from 'fs-extra';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import prompts from 'prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getConfig } from '../utils/config.js';
-import { registry } from '../registry/index.js';
+import { registry, getComponentNames } from '../registry/index.js';
 import { installPackages } from '../utils/package-manager.js';
 import { writeShortcutRegistryIndex } from '../utils/shortcut-registry.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// ---------------------------------------------------------------------------
-// Path & URL helpers
-// ---------------------------------------------------------------------------
-function validateBranch(branch) {
-    if (!/^[\w.\-/]+$/.test(branch)) {
-        throw new Error(`Invalid branch name: ${branch}`);
-    }
-}
-function getRegistryBaseUrl(branch) {
-    validateBranch(branch);
-    return `https://raw.githubusercontent.com/gilav21/shadcn-angular/${branch}/packages/components/ui`;
-}
-function getLibRegistryBaseUrl(branch) {
-    validateBranch(branch);
-    return `https://raw.githubusercontent.com/gilav21/shadcn-angular/${branch}/packages/components/lib`;
-}
-function getLocalComponentsDir() {
-    const localPath = path.resolve(__dirname, '../../../components/ui');
-    return fs.existsSync(localPath) ? localPath : null;
-}
-function getLocalLibDir() {
-    const fromDist = path.resolve(__dirname, '../../../components/lib');
-    if (fs.existsSync(fromDist)) {
-        return fromDist;
-    }
-    return null;
-}
-function resolveProjectPath(cwd, inputPath) {
-    const resolved = path.resolve(cwd, inputPath);
-    const relative = path.relative(cwd, resolved);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        throw new Error(`Path must stay inside the project directory: ${inputPath}`);
-    }
-    return resolved;
-}
-function aliasToProjectPath(aliasOrPath) {
-    return aliasOrPath.startsWith('@/')
-        ? path.join('src', aliasOrPath.slice(2))
-        : aliasOrPath;
-}
+import { getRegistryBaseUrl, getLibRegistryBaseUrl, getLocalComponentsDir, getLocalLibDir, resolveProjectPath, aliasToProjectPath, } from '../utils/paths.js';
+const onCancel = () => {
+    console.log(chalk.dim('\nCancelled.'));
+    process.exit(0);
+};
 export function normalizeContent(str) {
     return str.replaceAll('\r\n', '\n').trim();
 }
@@ -64,7 +26,7 @@ async function fetchComponentContent(file, options) {
             return fs.readFile(localPath, 'utf-8');
         }
     }
-    const url = `${getRegistryBaseUrl(options.branch)}/${file}`;
+    const url = `${getRegistryBaseUrl(options.branch, options.registry)}/${file}`;
     try {
         const response = await fetch(url);
         if (!response.ok) {
@@ -87,7 +49,7 @@ async function fetchLibContent(file, options) {
             return fs.readFile(localPath, 'utf-8');
         }
     }
-    const url = `${getLibRegistryBaseUrl(options.branch)}/${file}`;
+    const url = `${getLibRegistryBaseUrl(options.branch, options.registry)}/${file}`;
     const response = await fetch(url);
     if (!response.ok) {
         throw new Error(`Failed to fetch library file from ${url}: ${response.statusText}`);
@@ -104,28 +66,28 @@ export async function fetchAndTransform(file, options, utilsAlias) {
 // ---------------------------------------------------------------------------
 async function selectComponents(components, options) {
     if (options.all) {
-        return Object.keys(registry);
+        return getComponentNames();
     }
     if (components.length === 0) {
         const { selected } = await prompts({
             type: 'multiselect',
             name: 'selected',
             message: 'Which components would you like to add?',
-            choices: Object.keys(registry).map(name => ({
+            choices: getComponentNames().map(name => ({
                 title: name,
                 value: name,
             })),
             hint: '- Space to select, Enter to confirm',
-        });
+        }, { onCancel });
         return selected;
     }
     return components;
 }
 function validateComponents(names) {
-    const invalid = names.filter(c => !registry[c]);
+    const invalid = names.filter(c => !(c in registry));
     if (invalid.length > 0) {
         console.log(chalk.red(`Invalid component(s): ${invalid.join(', ')}`));
-        console.log(chalk.dim('Available components: ' + Object.keys(registry).join(', ')));
+        console.log(chalk.dim('Available components: ' + getComponentNames().join(', ')));
         process.exit(1);
     }
 }
@@ -135,9 +97,12 @@ export function resolveDependencies(names) {
         if (all.has(name))
             return;
         all.add(name);
-        registry[name].dependencies?.forEach(dep => walk(dep));
+        for (const dep of registry[name].dependencies ?? []) {
+            walk(dep);
+        }
     };
-    names.forEach(walk);
+    for (const name of names)
+        walk(name);
     return all;
 }
 export async function promptOptionalDependencies(resolved, options) {
@@ -169,7 +134,7 @@ export async function promptOptionalDependencies(resolved, options) {
             value: c.name,
         })),
         hint: '- Space to select, Enter to confirm (or press Enter to skip)',
-    });
+    }, { onCancel });
     return selected || [];
 }
 // ---------------------------------------------------------------------------
@@ -214,20 +179,48 @@ export async function classifyComponent(name, targetDir, options, utilsAlias, co
             ownFilesChanged = true;
     }
     await checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
+    if (options.overwrite)
+        return isFullyPresent ? 'conflict' : 'install';
     if (isFullyPresent && !ownFilesChanged)
         return 'skip';
     if (ownFilesChanged)
         return 'conflict';
     return 'install';
 }
+class ConcurrencyLimiter {
+    concurrency;
+    active = 0;
+    queue = [];
+    constructor(concurrency) {
+        this.concurrency = concurrency;
+    }
+    async run(fn) {
+        if (this.active >= this.concurrency) {
+            await new Promise(resolve => this.queue.push(resolve));
+        }
+        this.active++;
+        try {
+            return await fn();
+        }
+        finally {
+            this.active--;
+            if (this.queue.length > 0)
+                this.queue.shift()();
+        }
+    }
+}
 export async function detectConflicts(allComponents, targetDir, options, utilsAlias) {
     const toInstall = [];
     const toSkip = [];
     const conflicting = [];
     const peerFilesToUpdate = new Set();
     const contentCache = new Map();
-    for (const name of allComponents) {
-        const result = await classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
+    const limiter = new ConcurrencyLimiter(8);
+    const results = await Promise.all([...allComponents].map(name => limiter.run(async () => ({
+        name,
+        result: await classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate),
+    }))));
+    for (const { name, result } of results) {
         if (result === 'skip')
             toSkip.push(name);
         else if (result === 'conflict')
@@ -240,21 +233,42 @@ export async function detectConflicts(allComponents, targetDir, options, utilsAl
 // ---------------------------------------------------------------------------
 // Overwrite prompt
 // ---------------------------------------------------------------------------
-async function promptOverwrite(conflicting, options) {
+function showConflictDiffs(conflicting, targetDir, contentCache) {
+    for (const name of conflicting) {
+        const component = registry[name];
+        const changedFiles = [];
+        for (const file of component.files) {
+            const remote = contentCache.get(file);
+            if (!remote)
+                continue;
+            const localPath = path.join(targetDir, file);
+            if (!fs.existsSync(localPath))
+                continue;
+            const local = normalizeContent(fs.readFileSync(localPath, 'utf-8'));
+            if (local !== normalizeContent(remote)) {
+                changedFiles.push(file);
+            }
+        }
+        if (changedFiles.length > 0) {
+            console.log(chalk.dim(`  ${name}: `) + chalk.yellow(changedFiles.join(', ')));
+        }
+    }
+}
+async function promptOverwrite(conflicting, options, targetDir, contentCache) {
     if (conflicting.length === 0)
         return [];
-    if (options.overwrite)
+    if (options.overwrite || options.yes)
         return conflicting;
-    if (options.yes)
-        return [];
-    console.log(chalk.yellow(`\n${conflicting.length} component(s) have local changes or are different from remote.`));
+    console.log(chalk.yellow(`\n${conflicting.length} component(s) have local changes or are different from remote:`));
+    showConflictDiffs(conflicting, targetDir, contentCache);
+    console.log(chalk.dim('\n  Use `npx shadcn-angular diff <component>` for full diffs.\n'));
     const { selected } = await prompts({
         type: 'multiselect',
         name: 'selected',
         message: 'Select components to OVERWRITE (Unselected will be skipped):',
         choices: conflicting.map(name => ({ title: name, value: name })),
         hint: '- Space to select, Enter to confirm',
-    });
+    }, { onCancel });
     return selected || [];
 }
 // ---------------------------------------------------------------------------
@@ -297,32 +311,42 @@ async function writePeerFiles(component, targetDir, options, utilsAlias, content
         }
     }
 }
+async function installSingleLibFile(libFile, libDir, options) {
+    const targetPath = path.join(libDir, libFile);
+    const content = await fetchLibContent(libFile, options);
+    if (!await fs.pathExists(targetPath) || options.overwrite) {
+        await fs.writeFile(targetPath, content);
+        return;
+    }
+    const local = normalizeContent(await fs.readFile(targetPath, 'utf-8'));
+    if (local !== normalizeContent(content)) {
+        console.log(chalk.yellow(`  Lib file ${libFile} differs from remote (use --overwrite to update)`));
+    }
+}
 async function installLibFiles(allComponents, cwd, libDir, options) {
     const required = new Set();
     for (const name of allComponents) {
-        registry[name].libFiles?.forEach(f => required.add(f));
+        for (const f of registry[name].libFiles ?? [])
+            required.add(f);
     }
     if (required.size === 0)
         return;
     await fs.ensureDir(libDir);
     for (const libFile of required) {
-        const targetPath = path.join(libDir, libFile);
-        if (!await fs.pathExists(targetPath) || options.overwrite) {
-            try {
-                const content = await fetchLibContent(libFile, options);
-                await fs.writeFile(targetPath, content);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.warn(chalk.yellow(`Could not install lib file ${libFile}: ${message}`));
-            }
+        try {
+            await installSingleLibFile(libFile, libDir, options);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(chalk.yellow(`Could not install lib file ${libFile}: ${message}`));
         }
     }
 }
 async function installNpmDependencies(finalComponents, cwd) {
     const deps = new Set();
     for (const name of finalComponents) {
-        registry[name].npmDependencies?.forEach(dep => deps.add(dep));
+        for (const dep of registry[name].npmDependencies ?? [])
+            deps.add(dep);
     }
     if (deps.size === 0)
         return;
@@ -333,7 +357,12 @@ async function installNpmDependencies(finalComponents, cwd) {
     }
     catch (e) {
         spinner.fail('Failed to install dependencies.');
-        console.error(e);
+        if (e && typeof e === 'object' && 'stderr' in e && typeof e.stderr === 'string') {
+            console.error(chalk.red(e.stderr));
+        }
+        else {
+            console.error(e);
+        }
     }
 }
 async function ensureShortcutService(targetDir, cwd, config, options) {
@@ -363,6 +392,57 @@ function collectInstalledShortcutEntries(targetDir) {
     return entries;
 }
 // ---------------------------------------------------------------------------
+// Peer file & summary helpers
+// ---------------------------------------------------------------------------
+function pruneDeclinedPeerFiles(declined, finalComponents, peerFilesToUpdate) {
+    for (const name of declined) {
+        const component = registry[name];
+        if (!component.peerFiles)
+            continue;
+        for (const file of component.peerFiles) {
+            const stillNeeded = finalComponents.some(fc => registry[fc].peerFiles?.includes(file));
+            if (!stillNeeded) {
+                peerFilesToUpdate.delete(file);
+            }
+        }
+    }
+}
+function printNothingToInstall(toSkip, declined) {
+    if (toSkip.length > 0 || declined.length > 0) {
+        printSkipSummary(toSkip, declined);
+    }
+    else {
+        console.log(chalk.dim('\nNo components to install.'));
+    }
+}
+function printDryRunSummary(toInstall, toOverwrite, toSkip, declined) {
+    console.log(chalk.bold('\n[Dry Run] No changes will be made.\n'));
+    if (toInstall.length > 0) {
+        console.log(chalk.green(`  Would install ${toInstall.length} component(s):`));
+        for (const name of toInstall)
+            console.log(chalk.dim('    + ') + chalk.cyan(name));
+    }
+    if (toOverwrite.length > 0) {
+        console.log(chalk.yellow(`  Would overwrite ${toOverwrite.length} component(s):`));
+        for (const name of toOverwrite)
+            console.log(chalk.dim('    ~ ') + chalk.yellow(name));
+    }
+    printSkipSummary(toSkip, declined);
+    console.log('');
+}
+function printSkipSummary(toSkip, declined) {
+    if (toSkip.length > 0) {
+        console.log('\n' + chalk.dim('Components skipped (up to date):'));
+        for (const name of toSkip)
+            console.log(chalk.dim('  - ') + chalk.gray(name));
+    }
+    if (declined.length > 0) {
+        console.log('\n' + chalk.dim('Components skipped (kept local changes):'));
+        for (const name of declined)
+            console.log(chalk.dim('  - ') + chalk.yellow(name));
+    }
+}
+// ---------------------------------------------------------------------------
 // Main entry point
 // ---------------------------------------------------------------------------
 export async function add(components, options) {
@@ -373,6 +453,10 @@ export async function add(components, options) {
         console.log(chalk.dim('Run `npx @gilav21/shadcn-angular init` first.'));
         process.exit(1);
     }
+    // CLI flag takes priority over components.json
+    if (!options.registry && config.registry) {
+        options.registry = config.registry;
+    }
     const componentsToAdd = await selectComponents(components, options);
     if (!componentsToAdd || componentsToAdd.length === 0) {
         console.log(chalk.dim('No components selected.'));
@@ -387,45 +471,23 @@ export async function add(components, options) {
     const uiBasePath = options.path ?? aliasToProjectPath(config.aliases.ui || 'src/components/ui');
     const targetDir = resolveProjectPath(cwd, uiBasePath);
     const utilsAlias = config.aliases.utils;
-    // Detect conflicts
     const checkSpinner = ora('Checking for conflicts...').start();
     const { toInstall, toSkip, conflicting, peerFilesToUpdate, contentCache } = await detectConflicts(allComponents, targetDir, options, utilsAlias);
     checkSpinner.stop();
-    // Prompt user for overwrite decisions
-    const toOverwrite = await promptOverwrite(conflicting, options);
+    const toOverwrite = await promptOverwrite(conflicting, options, targetDir, contentCache);
     const finalComponents = [...toInstall, ...toOverwrite];
-    // Remove peer files that belong only to declined components
     const declined = conflicting.filter(c => !toOverwrite.includes(c));
-    for (const name of declined) {
-        const component = registry[name];
-        if (!component.peerFiles)
-            continue;
-        for (const file of component.peerFiles) {
-            const stillNeeded = finalComponents.some(fc => registry[fc].peerFiles?.includes(file));
-            if (!stillNeeded) {
-                peerFilesToUpdate.delete(file);
-            }
-        }
+    pruneDeclinedPeerFiles(declined, finalComponents, peerFilesToUpdate);
+    if (options.dryRun) {
+        printDryRunSummary(toInstall, toOverwrite, toSkip, declined);
+        return;
     }
     if (finalComponents.length === 0) {
-        if (toSkip.length > 0 || declined.length > 0) {
-            if (toSkip.length > 0) {
-                console.log(chalk.green(`\nAll components are up to date! (${toSkip.length} skipped)`));
-            }
-            if (declined.length > 0) {
-                console.log('\n' + chalk.dim('Components skipped (kept local changes):'));
-                declined.forEach(name => console.log(chalk.dim('  - ') + chalk.yellow(name)));
-            }
-        }
-        else {
-            console.log(chalk.dim('\nNo components to install.'));
-        }
+        printNothingToInstall(toSkip, declined);
         return;
     }
-    // Install component files
     const spinner = ora('Installing components...').start();
     let successCount = 0;
-    const finalComponentSet = new Set(finalComponents);
     try {
         await fs.ensureDir(targetDir);
         for (const name of finalComponents) {
@@ -440,24 +502,17 @@ export async function add(components, options) {
         if (successCount > 0) {
             spinner.succeed(chalk.green(`Success! Added ${successCount} component(s)`));
             console.log('\n' + chalk.dim('Components added:'));
-            finalComponents.forEach(name => console.log(chalk.dim('  - ') + chalk.cyan(name)));
+            for (const name of finalComponents)
+                console.log(chalk.dim('  - ') + chalk.cyan(name));
         }
         else {
             spinner.info('No new components installed.');
         }
-        // Post-install: lib files, npm deps, shortcuts
         const libDir = resolveProjectPath(cwd, aliasToProjectPath(utilsAlias));
-        await installLibFiles(finalComponentSet, cwd, libDir, options);
+        await installLibFiles(new Set(finalComponents), cwd, libDir, options);
         await installNpmDependencies(finalComponents, cwd);
         await ensureShortcutService(targetDir, cwd, config, options);
-        if (toSkip.length > 0) {
-            console.log('\n' + chalk.dim('Components skipped (up to date):'));
-            toSkip.forEach(name => console.log(chalk.dim('  - ') + chalk.gray(name)));
-        }
-        if (declined.length > 0) {
-            console.log('\n' + chalk.dim('Components skipped (kept local changes):'));
-            declined.forEach(name => console.log(chalk.dim('  - ') + chalk.yellow(name)));
-        }
+        printSkipSummary(toSkip, declined);
         console.log('');
     }
     catch (error) {

package/dist/commands/add.spec.js

@@ -230,20 +230,20 @@ describe('detectConflicts', () => {
 describe('peer file filtering logic', () => {
     it('removes peer files of declined components from peerFilesToUpdate', () => {
         const peerFilesToUpdate = new Set(['shared/peer-a.ts', 'shared/peer-b.ts', 'shared/peer-c.ts']);
-        const conflicting = ['compA', 'compB'];
-        const toOverwrite = ['compA'];
-        const finalComponents = ['compA'];
+        const conflicting = new Set(['compA', 'compB']);
+        const toOverwrite = new Set(['compA']);
+        const finalComponents = new Set(['compA']);
         const mockPeerFiles = {
             compA: ['shared/peer-a.ts'],
             compB: ['shared/peer-b.ts', 'shared/peer-c.ts'],
         };
-        const declined = conflicting.filter(c => !toOverwrite.includes(c));
+        const declined = [...conflicting].filter(c => !toOverwrite.has(c));
         for (const name of declined) {
             const peerFiles = mockPeerFiles[name];
             if (!peerFiles)
                 continue;
             for (const file of peerFiles) {
-                const stillNeeded = finalComponents.some(fc => mockPeerFiles[fc]?.includes(file));
+                const stillNeeded = [...finalComponents].some(fc => mockPeerFiles[fc]?.includes(file));
                 if (!stillNeeded) {
                     peerFilesToUpdate.delete(file);
                 }
@@ -255,20 +255,20 @@ describe('peer file filtering logic', () => {
     });
     it('keeps shared peer files when another final component still needs them', () => {
         const peerFilesToUpdate = new Set(['shared/common.ts']);
-        const conflicting = ['compA', 'compB'];
-        const toOverwrite = ['compA'];
-        const finalComponents = ['compA'];
+        const conflicting = new Set(['compA', 'compB']);
+        const toOverwrite = new Set(['compA']);
+        const finalComponents = new Set(['compA']);
         const mockPeerFiles = {
             compA: ['shared/common.ts'],
             compB: ['shared/common.ts'],
         };
-        const declined = conflicting.filter(c => !toOverwrite.includes(c));
+        const declined = [...conflicting].filter(c => !toOverwrite.has(c));
         for (const name of declined) {
             const peerFiles = mockPeerFiles[name];
             if (!peerFiles)
                 continue;
             for (const file of peerFiles) {
-                const stillNeeded = finalComponents.some(fc => mockPeerFiles[fc]?.includes(file));
+                const stillNeeded = [...finalComponents].some(fc => mockPeerFiles[fc]?.includes(file));
                 if (!stillNeeded) {
                     peerFilesToUpdate.delete(file);
                 }
@@ -278,23 +278,17 @@ describe('peer file filtering logic', () => {
     });
     it('removes all peer files when all components are declined', () => {
         const peerFilesToUpdate = new Set(['shared/peer-a.ts', 'shared/peer-b.ts']);
-        const conflicting = ['compA', 'compB'];
-        const toOverwrite = [];
-        const finalComponents = [];
+        const declined = ['compA', 'compB'];
         const mockPeerFiles = {
             compA: ['shared/peer-a.ts'],
             compB: ['shared/peer-b.ts'],
         };
-        const declined = conflicting.filter(c => !toOverwrite.includes(c));
         for (const name of declined) {
             const peerFiles = mockPeerFiles[name];
             if (!peerFiles)
                 continue;
             for (const file of peerFiles) {
-                const stillNeeded = finalComponents.some(fc => mockPeerFiles[fc]?.includes(file));
-                if (!stillNeeded) {
-                    peerFilesToUpdate.delete(file);
-                }
+                peerFilesToUpdate.delete(file);
             }
         }
         expect(peerFilesToUpdate.size).toBe(0);
@@ -323,9 +317,9 @@ describe('resolveDependencies', () => {
         expect(result).toContain('select');
     });
     it('deduplicates shared dependencies across multiple inputs', () => {
-        const result = resolveDependencies(['button-group', 'speed-dial']);
-        expect(result).toContain('button-group');
-        expect(result).toContain('speed-dial');
+        const result = resolveDependencies(['date-picker', 'sparkles']);
+        expect(result).toContain('date-picker');
+        expect(result).toContain('sparkles');
         expect(result).toContain('button');
         expect(result).toContain('ripple');
         const asArray = [...result];
@@ -393,7 +387,7 @@ describe('registry optional dependencies', () => {
             if (!definition.optionalDependencies)
                 continue;
             for (const opt of definition.optionalDependencies) {
-                expect(registry[opt.name], `Optional dep "${opt.name}" in "${componentName}" is not a valid registry key`).toBeDefined();
+                expect(opt.name in registry, `Optional dep "${opt.name}" in "${componentName}" is not a valid registry key`).toBe(true);
             }
         }
     });
@@ -402,7 +396,7 @@ describe('registry optional dependencies', () => {
             if (!definition.dependencies)
                 continue;
             for (const dep of definition.dependencies) {
-                expect(registry[dep], `Dependency "${dep}" in "${componentName}" is not a valid registry key`).toBeDefined();
+                expect(dep in registry, `Dependency "${dep}" in "${componentName}" is not a valid registry key`).toBe(true);
             }
         }
     });

package/dist/commands/diff.d.ts

@@ -0,0 +1,8 @@
+interface DiffOptions {
+    branch: string;
+    remote?: boolean;
+    registry?: string;
+}
+export declare function formatUnifiedDiff(fileName: string, localContent: string, remoteContent: string): string;
+export declare function diff(components: string[], options: DiffOptions): Promise<void>;
+export {};