@gilav21/shadcn-angular 0.0.22 → 0.0.23

package/dist/commands/add.d.ts

@@ -1,5 +1,5 @@
 import { type ComponentName } from '../registry/index.js';
-interface AddOptions {
+export interface AddOptions {
     yes?: boolean;
     overwrite?: boolean;
     all?: boolean;
@@ -7,7 +7,19 @@ interface AddOptions {
     remote?: boolean;
     branch: string;
 }
+interface ConflictCheckResult {
+    toInstall: ComponentName[];
+    toSkip: string[];
+    conflicting: ComponentName[];
+    peerFilesToUpdate: Set<string>;
+    contentCache: Map<string, string>;
+}
+export declare function normalizeContent(str: string): string;
+export declare function fetchAndTransform(file: string, options: AddOptions, utilsAlias: string): Promise<string>;
 export declare function resolveDependencies(names: ComponentName[]): Set<ComponentName>;
 export declare function promptOptionalDependencies(resolved: Set<ComponentName>, options: AddOptions): Promise<ComponentName[]>;
+export declare function checkFileConflict(file: string, targetDir: string, options: AddOptions, utilsAlias: string, contentCache: Map<string, string>): Promise<'identical' | 'changed' | 'missing'>;
+export declare function classifyComponent(name: ComponentName, targetDir: string, options: AddOptions, utilsAlias: string, contentCache: Map<string, string>, peerFilesToUpdate: Set<string>): Promise<'install' | 'skip' | 'conflict'>;
+export declare function detectConflicts(allComponents: Set<ComponentName>, targetDir: string, options: AddOptions, utilsAlias: string): Promise<ConflictCheckResult>;
 export declare function add(components: string[], options: AddOptions): Promise<void>;
 export {};

package/dist/commands/add.js

@@ -50,7 +50,7 @@ function aliasToProjectPath(aliasOrPath) {
         ? path.join('src', aliasOrPath.slice(2))
         : aliasOrPath;
 }
-function normalizeContent(str) {
+export function normalizeContent(str) {
     return str.replaceAll('\r\n', '\n').trim();
 }
 // ---------------------------------------------------------------------------
@@ -94,9 +94,9 @@ async function fetchLibContent(file, options) {
     }
     return response.text();
 }
-async function fetchAndTransform(file, options, utilsAlias) {
+export async function fetchAndTransform(file, options, utilsAlias) {
     let content = await fetchComponentContent(file, options);
-    content = content.replaceAll(/(\.\.\/)+lib\//, utilsAlias + '/');
+    content = content.replaceAll(/(\.\.\/)+lib\//g, utilsAlias + '/');
     return content;
 }
 // ---------------------------------------------------------------------------
@@ -175,7 +175,7 @@ export async function promptOptionalDependencies(resolved, options) {
 // ---------------------------------------------------------------------------
 // Conflict detection
 // ---------------------------------------------------------------------------
-async function checkFileConflict(file, targetDir, options, utilsAlias, contentCache) {
+export async function checkFileConflict(file, targetDir, options, utilsAlias, contentCache) {
     const targetPath = path.join(targetDir, file);
     if (!await fs.pathExists(targetPath)) {
         return 'missing';
@@ -194,38 +194,33 @@ async function checkFileConflict(file, targetDir, options, utilsAlias, contentCa
 }
 async function checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate) {
     if (!component.peerFiles)
-        return false;
-    let hasChanges = false;
+        return;
     for (const file of component.peerFiles) {
         const status = await checkFileConflict(file, targetDir, options, utilsAlias, contentCache);
         if (status === 'changed') {
-            hasChanges = true;
             peerFilesToUpdate.add(file);
         }
     }
-    return hasChanges;
 }
-async function classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate) {
+export async function classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate) {
     const component = registry[name];
-    let hasChanges = false;
+    let ownFilesChanged = false;
     let isFullyPresent = true;
     for (const file of component.files) {
         const status = await checkFileConflict(file, targetDir, options, utilsAlias, contentCache);
         if (status === 'missing')
             isFullyPresent = false;
         if (status === 'changed')
-            hasChanges = true;
+            ownFilesChanged = true;
     }
-    const peerChanged = await checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
-    if (peerChanged)
-        hasChanges = true;
-    if (isFullyPresent && !hasChanges)
+    await checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
+    if (isFullyPresent && !ownFilesChanged)
         return 'skip';
-    if (hasChanges)
+    if (ownFilesChanged)
         return 'conflict';
     return 'install';
 }
-async function detectConflicts(allComponents, targetDir, options, utilsAlias) {
+export async function detectConflicts(allComponents, targetDir, options, utilsAlias) {
     const toInstall = [];
     const toSkip = [];
     const conflicting = [];
@@ -399,9 +394,28 @@ export async function add(components, options) {
     // Prompt user for overwrite decisions
     const toOverwrite = await promptOverwrite(conflicting, options);
     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);
+            }
+        }
+    }
     if (finalComponents.length === 0) {
-        if (toSkip.length > 0) {
-            console.log(chalk.green(`\nAll components are up to date! (${toSkip.length} skipped)`));
+        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.'));
@@ -411,6 +425,7 @@ export async function add(components, options) {
     // 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) {
@@ -432,13 +447,17 @@ export async function add(components, options) {
         }
         // Post-install: lib files, npm deps, shortcuts
         const libDir = resolveProjectPath(cwd, aliasToProjectPath(utilsAlias));
-        await installLibFiles(allComponents, cwd, libDir, options);
+        await installLibFiles(finalComponentSet, 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)));
+        }
         console.log('');
     }
     catch (error) {

package/dist/commands/add.spec.js

@@ -1,6 +1,305 @@
-import { describe, it, expect, vi } from 'vitest';
-import { resolveDependencies, promptOptionalDependencies } from './add.js';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { resolveDependencies, promptOptionalDependencies, normalizeContent, fetchAndTransform, checkFileConflict, classifyComponent, detectConflicts, } from './add.js';
 import { registry } from '../registry/index.js';
+import fs from 'fs-extra';
+// ---------------------------------------------------------------------------
+// Module-level mocks
+// ---------------------------------------------------------------------------
+vi.mock('fs-extra', () => ({
+    default: {
+        existsSync: vi.fn(() => false),
+        pathExists: vi.fn(() => Promise.resolve(false)),
+        readFile: vi.fn(() => Promise.resolve('')),
+        writeFile: vi.fn(() => Promise.resolve()),
+        ensureDir: vi.fn(() => Promise.resolve()),
+    },
+}));
+vi.mock('prompts', () => ({
+    default: vi.fn(),
+}));
+const mockedFs = vi.mocked(fs);
+// ---------------------------------------------------------------------------
+// normalizeContent
+// ---------------------------------------------------------------------------
+describe('normalizeContent', () => {
+    it('trims whitespace from both ends', () => {
+        expect(normalizeContent('  hello  ')).toBe('hello');
+    });
+    it('converts CRLF to LF', () => {
+        expect(normalizeContent('line1\r\nline2\r\n')).toBe('line1\nline2');
+    });
+    it('handles mixed line endings', () => {
+        expect(normalizeContent('a\r\nb\nc\r\n')).toBe('a\nb\nc');
+    });
+    it('returns empty string for whitespace-only input', () => {
+        expect(normalizeContent('   \r\n  ')).toBe('');
+    });
+});
+// ---------------------------------------------------------------------------
+// fetchAndTransform
+// ---------------------------------------------------------------------------
+describe('fetchAndTransform', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        mockedFs.existsSync.mockReturnValue(false);
+    });
+    it('replaces single-level relative lib imports with alias', async () => {
+        const mockContent = "import { cn } from '../lib/utils';";
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(mockContent, { status: 200 }));
+        const result = await fetchAndTransform('button/button.ts', { branch: 'master', remote: true }, '@/components/lib');
+        expect(result).toBe("import { cn } from '@/components/lib/utils';");
+    });
+    it('replaces multi-level relative lib imports with alias', async () => {
+        const mockContent = "import { cn } from '../../lib/utils';";
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(mockContent, { status: 200 }));
+        const result = await fetchAndTransform('deep/nested/comp.ts', { branch: 'master', remote: true }, '@/components/lib');
+        expect(result).toBe("import { cn } from '@/components/lib/utils';");
+    });
+    it('replaces all occurrences in a file (global regex)', async () => {
+        const mockContent = [
+            "import { cn } from '../lib/utils';",
+            "import { foo } from '../lib/helpers';",
+        ].join('\n');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(mockContent, { status: 200 }));
+        const result = await fetchAndTransform('comp.ts', { branch: 'master', remote: true }, '@/lib');
+        expect(result).toBe([
+            "import { cn } from '@/lib/utils';",
+            "import { foo } from '@/lib/helpers';",
+        ].join('\n'));
+    });
+    it('does not throw with replaceAll and regex (the original bug)', async () => {
+        const mockContent = "import { cn } from '../lib/utils';";
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(mockContent, { status: 200 }));
+        await expect(fetchAndTransform('comp.ts', { branch: 'master', remote: true }, '@/lib')).resolves.not.toThrow();
+    });
+    it('leaves content unchanged when no lib imports exist', async () => {
+        const mockContent = "import { Component } from '@angular/core';";
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(mockContent, { status: 200 }));
+        const result = await fetchAndTransform('comp.ts', { branch: 'master', remote: true }, '@/lib');
+        expect(result).toBe("import { Component } from '@angular/core';");
+    });
+});
+// ---------------------------------------------------------------------------
+// checkFileConflict
+// ---------------------------------------------------------------------------
+describe('checkFileConflict', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        mockedFs.existsSync.mockReturnValue(false);
+    });
+    it('returns "missing" when file does not exist on disk', async () => {
+        mockedFs.pathExists.mockResolvedValue(false);
+        const cache = new Map();
+        const result = await checkFileConflict('button/button.ts', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache);
+        expect(result).toBe('missing');
+    });
+    it('returns "identical" when local and remote content match', async () => {
+        const content = "import { cn } from '@/lib/utils';\nexport class Button {}";
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue(content);
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(content.replaceAll('@/lib/', '../lib/'), { status: 200 }));
+        const cache = new Map();
+        const result = await checkFileConflict('button/button.ts', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache);
+        expect(result).toBe('identical');
+    });
+    it('returns "changed" when local and remote content differ', async () => {
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue('// local modified version');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// remote original version', { status: 200 }));
+        const cache = new Map();
+        const result = await checkFileConflict('button/button.ts', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache);
+        expect(result).toBe('changed');
+    });
+    it('populates the content cache on successful fetch', async () => {
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue('// local');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// remote', { status: 200 }));
+        const cache = new Map();
+        await checkFileConflict('button/button.ts', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache);
+        expect(cache.has('button/button.ts')).toBe(true);
+        expect(cache.get('button/button.ts')).toBe('// remote');
+    });
+});
+// ---------------------------------------------------------------------------
+// classifyComponent — peer-file decoupling
+// ---------------------------------------------------------------------------
+describe('classifyComponent', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        mockedFs.existsSync.mockReturnValue(false);
+    });
+    it('returns "install" when component files are missing', async () => {
+        mockedFs.pathExists.mockResolvedValue(false);
+        const cache = new Map();
+        const peerFiles = new Set();
+        const result = await classifyComponent('badge', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache, peerFiles);
+        expect(result).toBe('install');
+    });
+    it('returns "skip" when all component files are present and identical', async () => {
+        const content = '// badge content';
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue(content);
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(content, { status: 200 }));
+        const cache = new Map();
+        const peerFiles = new Set();
+        const result = await classifyComponent('badge', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache, peerFiles);
+        expect(result).toBe('skip');
+    });
+    it('returns "conflict" when own files have changed', async () => {
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue('// modified locally');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// original remote', { status: 200 }));
+        const cache = new Map();
+        const peerFiles = new Set();
+        const result = await classifyComponent('badge', '/project/ui', { branch: 'master', remote: true }, '@/lib', cache, peerFiles);
+        expect(result).toBe('conflict');
+    });
+    it('does NOT return "conflict" when only peer files have changed', async () => {
+        const componentWithPeers = Object.entries(registry).find(([, def]) => def.peerFiles && def.peerFiles.length > 0);
+        if (!componentWithPeers) {
+            return;
+        }
+        const [name, def] = componentWithPeers;
+        let readCallCount = 0;
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockImplementation((() => {
+            readCallCount++;
+            if (readCallCount <= def.files.length) {
+                return Promise.resolve('// identical content');
+            }
+            return Promise.resolve('// modified peer file');
+        }));
+        vi.spyOn(globalThis, 'fetch').mockImplementation(() => Promise.resolve(new Response('// identical content', { status: 200 })));
+        const cache = new Map();
+        const peerFilesToUpdate = new Set();
+        const result = await classifyComponent(name, '/project/ui', { branch: 'master', remote: true }, '@/lib', cache, peerFilesToUpdate);
+        expect(result).toBe('skip');
+        expect(peerFilesToUpdate.size).toBeGreaterThan(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// detectConflicts
+// ---------------------------------------------------------------------------
+describe('detectConflicts', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        mockedFs.existsSync.mockReturnValue(false);
+    });
+    it('classifies missing components as toInstall', async () => {
+        mockedFs.pathExists.mockResolvedValue(false);
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// content', { status: 200 }));
+        const components = new Set(['badge']);
+        const result = await detectConflicts(components, '/project/ui', { branch: 'master', remote: true }, '@/lib');
+        expect(result.toInstall).toContain('badge');
+        expect(result.conflicting).not.toContain('badge');
+        expect(result.toSkip).not.toContain('badge');
+    });
+    it('classifies identical components as toSkip', async () => {
+        const content = '// badge content';
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue(content);
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(content, { status: 200 }));
+        const components = new Set(['badge']);
+        const result = await detectConflicts(components, '/project/ui', { branch: 'master', remote: true }, '@/lib');
+        expect(result.toSkip).toContain('badge');
+        expect(result.toInstall).not.toContain('badge');
+        expect(result.conflicting).not.toContain('badge');
+    });
+    it('classifies changed components as conflicting', async () => {
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue('// modified locally');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// remote content', { status: 200 }));
+        const components = new Set(['badge']);
+        const result = await detectConflicts(components, '/project/ui', { branch: 'master', remote: true }, '@/lib');
+        expect(result.conflicting).toContain('badge');
+        expect(result.toInstall).not.toContain('badge');
+        expect(result.toSkip).not.toContain('badge');
+    });
+    it('populates contentCache for files it checks', async () => {
+        mockedFs.pathExists.mockResolvedValue(true);
+        mockedFs.readFile.mockResolvedValue('// local');
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('// remote', { status: 200 }));
+        const components = new Set(['badge']);
+        const result = await detectConflicts(components, '/project/ui', { branch: 'master', remote: true }, '@/lib');
+        expect(result.contentCache.size).toBeGreaterThan(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Peer file filtering after overwrite selection
+// ---------------------------------------------------------------------------
+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 mockPeerFiles = {
+            compA: ['shared/peer-a.ts'],
+            compB: ['shared/peer-b.ts', 'shared/peer-c.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);
+                }
+            }
+        }
+        expect(peerFilesToUpdate.has('shared/peer-a.ts')).toBe(true);
+        expect(peerFilesToUpdate.has('shared/peer-b.ts')).toBe(false);
+        expect(peerFilesToUpdate.has('shared/peer-c.ts')).toBe(false);
+    });
+    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 mockPeerFiles = {
+            compA: ['shared/common.ts'],
+            compB: ['shared/common.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);
+                }
+            }
+        }
+        expect(peerFilesToUpdate.has('shared/common.ts')).toBe(true);
+    });
+    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 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);
+                }
+            }
+        }
+        expect(peerFilesToUpdate.size).toBe(0);
+    });
+});
 // ---------------------------------------------------------------------------
 // resolveDependencies
 // ---------------------------------------------------------------------------
@@ -11,13 +310,11 @@ describe('resolveDependencies', () => {
         expect(result.size).toBe(1);
     });
     it('includes transitive dependencies', () => {
-        // button depends on ripple
         const result = resolveDependencies(['button']);
         expect(result).toContain('button');
         expect(result).toContain('ripple');
     });
     it('resolves deep transitive chains', () => {
-        // date-picker -> calendar -> button -> ripple, calendar -> select
         const result = resolveDependencies(['date-picker']);
         expect(result).toContain('date-picker');
         expect(result).toContain('calendar');
@@ -26,13 +323,11 @@ describe('resolveDependencies', () => {
         expect(result).toContain('select');
     });
     it('deduplicates shared dependencies across multiple inputs', () => {
-        // Both button-group and speed-dial depend on button
         const result = resolveDependencies(['button-group', 'speed-dial']);
         expect(result).toContain('button-group');
         expect(result).toContain('speed-dial');
         expect(result).toContain('button');
         expect(result).toContain('ripple');
-        // Count how many times button appears — should be exactly once (it's a Set)
         const asArray = [...result];
         expect(asArray.filter((n) => n === 'button')).toHaveLength(1);
     });
@@ -49,9 +344,6 @@ describe('resolveDependencies', () => {
 // ---------------------------------------------------------------------------
 // promptOptionalDependencies
 // ---------------------------------------------------------------------------
-vi.mock('prompts', () => ({
-    default: vi.fn(),
-}));
 describe('promptOptionalDependencies', () => {
     it('returns empty array when no components have optional deps', async () => {
         const resolved = new Set(['badge', 'button', 'ripple']);
@@ -69,13 +361,11 @@ describe('promptOptionalDependencies', () => {
         expect(result).toContain('context-menu');
     });
     it('filters out optional deps already in the resolved set', async () => {
-        // context-menu is already resolved, so it should not be offered
         const resolved = new Set(['data-table', 'context-menu', 'table', 'input', 'button', 'ripple', 'checkbox', 'select', 'pagination', 'popover', 'component-outlet', 'icon']);
         const result = await promptOptionalDependencies(resolved, { all: true, branch: 'master' });
         expect(result).not.toContain('context-menu');
     });
     it('deduplicates optional deps across components', async () => {
-        // Both data-table and tree have context-menu as optional
         const resolved = new Set(['data-table', 'tree', 'table', 'input', 'button', 'ripple', 'checkbox', 'select', 'pagination', 'popover', 'component-outlet', 'icon']);
         const result = await promptOptionalDependencies(resolved, { all: true, branch: 'master' });
         const contextMenuCount = result.filter((n) => n === 'context-menu').length;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gilav21/shadcn-angular",
-    "version": "0.0.22",
+    "version": "0.0.23",
     "description": "CLI for adding shadcn-angular components to your project",
     "bin": {
         "shadcn-angular": "./dist/index.js"