@gilav21/shadcn-angular 0.0.24 → 0.0.26

package/dist/utils/paths.js

@@ -0,0 +1,43 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function validateBranch(branch) {
+    if (!/^[\w.\-/]+$/.test(branch)) {
+        throw new Error(`Invalid branch name: ${branch}`);
+    }
+}
+function getDefaultRegistryBaseUrl(branch) {
+    validateBranch(branch);
+    return `https://raw.githubusercontent.com/gilav21/shadcn-angular/${branch}/packages/components`;
+}
+export function getRegistryBaseUrl(branch, customRegistry) {
+    const base = customRegistry ?? getDefaultRegistryBaseUrl(branch);
+    return `${base}/ui`;
+}
+export function getLibRegistryBaseUrl(branch, customRegistry) {
+    const base = customRegistry ?? getDefaultRegistryBaseUrl(branch);
+    return `${base}/lib`;
+}
+export function getLocalComponentsDir() {
+    const localPath = path.resolve(__dirname, '../../../../components/ui');
+    return fs.existsSync(localPath) ? localPath : null;
+}
+export function getLocalLibDir() {
+    const localPath = path.resolve(__dirname, '../../../../components/lib');
+    return fs.existsSync(localPath) ? localPath : null;
+}
+export 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;
+}
+export function aliasToProjectPath(aliasOrPath) {
+    return aliasOrPath.startsWith('@/')
+        ? path.join('src', aliasOrPath.slice(2))
+        : aliasOrPath;
+}

package/dist/utils/shortcut-registry.js

@@ -1,18 +1,6 @@
 import fs from 'fs-extra';
 import path from 'node:path';
-function aliasToProjectPath(aliasOrPath) {
-    return aliasOrPath.startsWith('@/')
-        ? path.join('src', aliasOrPath.slice(2))
-        : aliasOrPath;
-}
-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;
-}
+import { resolveProjectPath, aliasToProjectPath } from './paths.js';
 function getShortcutRegistryIndexPath(cwd, config) {
     const libDir = resolveProjectPath(cwd, aliasToProjectPath(config.aliases.utils));
     return path.join(libDir, 'shortcut-registry.index.ts');

package/package.json

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

package/scripts/sync-registry.ts

@@ -0,0 +1,347 @@
+#!/usr/bin/env tsx
+/**
+ * Recursively walks imports from each component's entry file,
+ * stopping at other component boundaries to discover only the
+ * files that belong to THIS component's tree.
+ *
+ * Usage:
+ *   npx tsx packages/cli/scripts/sync-registry.ts          # report only
+ *   npx tsx packages/cli/scripts/sync-registry.ts --fix     # update registry
+ */
+
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const CLI_SRC = path.resolve(SCRIPT_DIR, '../src');
+const COMPONENTS_ROOT = path.resolve(SCRIPT_DIR, '../../components');
+const REGISTRY_PATH = path.join(CLI_SRC, 'registry/index.ts');
+
+const IMPORT_REGEX = /from\s+['"](\.[^'"]+)['"]/g;
+
+// utils.ts is always installed during init — not a component libFile
+const BASELINE_LIB_FILES = new Set(['utils.ts']);
+
+// ── Parse registry ──────────────────────────────────────────────────────
+
+interface RegistryEntry {
+    name: string;
+    files: string[];
+    libFiles: string[];
+    dependencies: string[];
+}
+
+function parseRegistry(): RegistryEntry[] {
+    const source = readFileSync(REGISTRY_PATH, 'utf-8');
+    const entries: RegistryEntry[] = [];
+
+    const blockRegex = /['"]?([\w-]+)['"]?\s*:\s*\{[^}]*?name:\s*['"]([^'"]+)['"][^}]*?files:\s*\[([\s\S]*?)\]/g;
+    let match: RegExpExecArray | null;
+
+    while ((match = blockRegex.exec(source)) !== null) {
+        const name = match[2];
+        const filesRaw = match[3];
+        const files = [...filesRaw.matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1]);
+
+        const blockEnd = source.indexOf('},', match.index + match[0].length);
+        const fullBlock = source.slice(match.index, blockEnd === -1 ? undefined : blockEnd);
+        const libFilesMatch = /libFiles:\s*\[([\s\S]*?)\]/.exec(fullBlock);
+        const libFiles = libFilesMatch
+            ? [...libFilesMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1])
+            : [];
+
+        const depsMatch = /dependencies:\s*\[([\s\S]*?)\]/.exec(fullBlock);
+        const dependencies = depsMatch
+            ? [...depsMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1])
+            : [];
+
+        entries.push({ name, files, libFiles, dependencies });
+    }
+
+    return entries;
+}
+
+// ── Resolve imports ─────────────────────────────────────────────────────
+
+function resolveImport(importPath: string, fromFile: string): string | null {
+    const fromDir = path.dirname(path.join(COMPONENTS_ROOT, fromFile));
+    let resolved = path.resolve(fromDir, importPath);
+
+    if (!existsSync(resolved)) resolved += '.ts';
+    if (!existsSync(resolved)) return null;
+
+    return path.relative(COMPONENTS_ROOT, resolved).replaceAll('\\', '/');
+}
+
+// ── Tree walker with component boundaries ───────────────────────────────
+
+interface WalkResult {
+    ownFiles: Set<string>;
+    discoveredDeps: Set<string>;
+}
+
+function walkTree(
+    entryFile: string,
+    componentName: string,
+    entryFileToComponent: Map<string, string>,
+): WalkResult {
+    const ownFiles = new Set<string>();
+    const discoveredDeps = new Set<string>();
+
+    function collect(file: string): void {
+        if (ownFiles.has(file)) return;
+
+        // If this file is the entry point of ANOTHER component → dependency, stop
+        const ownerComponent = entryFileToComponent.get(file);
+        if (ownerComponent && ownerComponent !== componentName) {
+            discoveredDeps.add(ownerComponent);
+            return;
+        }
+
+        ownFiles.add(file);
+
+        const fullPath = path.join(COMPONENTS_ROOT, file);
+        if (!existsSync(fullPath)) return;
+
+        const content = readFileSync(fullPath, 'utf-8');
+        const regex = new RegExp(IMPORT_REGEX.source, IMPORT_REGEX.flags);
+        let match: RegExpExecArray | null;
+
+        while ((match = regex.exec(content)) !== null) {
+            const resolved = resolveImport(match[1], file);
+            if (resolved) collect(resolved);
+        }
+    }
+
+    collect(entryFile);
+    return { ownFiles, discoveredDeps };
+}
+
+// ── Split files into ui/ and lib/ ───────────────────────────────────────
+
+function splitFiles(allFiles: Set<string>): { uiFiles: string[]; libFiles: string[] } {
+    const uiFiles: string[] = [];
+    const libFiles: string[] = [];
+
+    for (const file of allFiles) {
+        if (file.startsWith('ui/')) {
+            uiFiles.push(file.slice(3));
+        } else if (file.startsWith('lib/')) {
+            const libName = file.slice(4);
+            if (!BASELINE_LIB_FILES.has(libName)) {
+                libFiles.push(libName);
+            }
+        }
+    }
+
+    uiFiles.sort((a, b) => a.localeCompare(b));
+    libFiles.sort((a, b) => a.localeCompare(b));
+    return { uiFiles, libFiles };
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function getEntryFile(entry: RegistryEntry): string {
+    // Barrel index.ts re-exports everything — use it when available
+    const indexFile = entry.files.find(f => f.endsWith('index.ts'));
+    if (indexFile) return indexFile;
+
+    // Convention: main file is {name}.component.ts or {name}.directive.ts
+    const baseName = entry.name.split('/').at(-1) ?? entry.name;
+    const conventionFile = entry.files.find(f =>
+        f.endsWith(`${baseName}.component.ts`) || f.endsWith(`${baseName}.directive.ts`),
+    );
+    return conventionFile ?? entry.files[0];
+}
+
+interface ComponentUpdate {
+    name: string;
+    files: string[];
+    libFiles: string[];
+    dependencies: string[];
+}
+
+function buildBoundaryMap(entries: RegistryEntry[]): Map<string, string> {
+    const map = new Map<string, string>();
+    for (const entry of entries) {
+        map.set('ui/' + getEntryFile(entry), entry.name);
+    }
+    return map;
+}
+
+function analyzeComponent(
+    entry: RegistryEntry,
+    entryFileToComponent: Map<string, string>,
+): { update: ComponentUpdate; changed: boolean } {
+    const entryFile = 'ui/' + getEntryFile(entry);
+    const { ownFiles, discoveredDeps } = walkTree(entryFile, entry.name, entryFileToComponent);
+    const { uiFiles, libFiles: discoveredLibs } = splitFiles(ownFiles);
+
+    const mergedLibFiles = [...new Set([...entry.libFiles, ...discoveredLibs])];
+    mergedLibFiles.sort((a, b) => a.localeCompare(b));
+
+    const finalDeps = [...discoveredDeps].sort((a, b) => a.localeCompare(b));
+
+    const addedFiles = uiFiles.filter(f => !entry.files.includes(f));
+    const removedFiles = entry.files.filter(f => !uiFiles.includes(f));
+    const addedLibs = discoveredLibs.filter(f => !entry.libFiles.includes(f));
+    const addedDeps = finalDeps.filter(d => !entry.dependencies.includes(d));
+    const removedDeps = entry.dependencies.filter(d => !finalDeps.includes(d));
+    const changed = addedFiles.length > 0 || removedFiles.length > 0
+        || addedLibs.length > 0 || addedDeps.length > 0 || removedDeps.length > 0;
+
+    if (changed) {
+        console.log(`  ${entry.name}:`);
+        for (const f of addedFiles) console.log(`    + files: ${f}`);
+        for (const f of removedFiles) console.log(`    - files: ${f}`);
+        for (const f of addedLibs) console.log(`    + libFiles: ${f}`);
+        for (const d of addedDeps) console.log(`    + dependencies: ${d}`);
+        for (const d of removedDeps) console.log(`    - dependencies: ${d}`);
+    }
+
+    return {
+        update: { name: entry.name, files: uiFiles, libFiles: mergedLibFiles, dependencies: finalDeps },
+        changed,
+    };
+}
+
+function findNamePos(source: string, name: string): number {
+    const singleQuote = source.indexOf(`name: '${name}'`);
+    if (singleQuote >= 0) return singleQuote;
+    return source.indexOf(`name: "${name}"`);
+}
+
+function replaceFilesArray(source: string, name: string, filesArrayStr: string): string {
+    const namePos = findNamePos(source, name);
+    if (namePos === -1) return source;
+
+    const filesStart = source.indexOf('files: [', namePos);
+    if (filesStart === -1) return source;
+    const filesEnd = source.indexOf(']', filesStart + 8);
+    if (filesEnd === -1) return source;
+
+    return source.slice(0, filesStart + 8) + filesArrayStr + source.slice(filesEnd);
+}
+
+function updateLibFiles(source: string, name: string, libArrayStr: string): string {
+    const updatedNamePos = findNamePos(source, name);
+    if (updatedNamePos === -1) return source;
+    const nextNamePos = source.indexOf('name: ', updatedNamePos + name.length + 8);
+    const blockEnd = nextNamePos === -1 ? source.length : nextNamePos;
+    const blockSlice = source.slice(updatedNamePos, blockEnd);
+
+    const libOffset = blockSlice.indexOf('libFiles: [');
+    if (libOffset >= 0) {
+        const absLibStart = updatedNamePos + libOffset;
+        const libEnd = source.indexOf(']', absLibStart + 11);
+        return source.slice(0, absLibStart + 11) + libArrayStr + source.slice(libEnd);
+    }
+
+    const absFilesStart = source.indexOf('files: [', updatedNamePos);
+    const absFilesEnd = source.indexOf(']', absFilesStart + 8);
+    return source.slice(0, absFilesEnd + 1) + `,\n    libFiles: [${libArrayStr}]` + source.slice(absFilesEnd + 1);
+}
+
+function updateDependencies(source: string, name: string, depsArrayStr: string): string {
+    const updatedNamePos = findNamePos(source, name);
+    if (updatedNamePos === -1) return source;
+    const nextNamePos = source.indexOf('name: ', updatedNamePos + name.length + 8);
+    const blockEnd = nextNamePos === -1 ? source.length : nextNamePos;
+    const blockSlice = source.slice(updatedNamePos, blockEnd);
+
+    const depsOffset = blockSlice.indexOf('dependencies: [');
+    if (depsOffset >= 0) {
+        const absDepsStart = updatedNamePos + depsOffset;
+        const depsEnd = source.indexOf(']', absDepsStart + 15);
+        return source.slice(0, absDepsStart + 15) + depsArrayStr + source.slice(depsEnd);
+    }
+
+    // Insert after files array (or after libFiles if present)
+    const libOffset = blockSlice.indexOf('libFiles: [');
+    if (libOffset >= 0) {
+        const absLibStart = updatedNamePos + libOffset;
+        const libEnd = source.indexOf(']', absLibStart + 11);
+        return source.slice(0, libEnd + 1) + `,\n    dependencies: [${depsArrayStr}]` + source.slice(libEnd + 1);
+    }
+
+    const absFilesStart = source.indexOf('files: [', updatedNamePos);
+    const absFilesEnd = source.indexOf(']', absFilesStart + 8);
+    return source.slice(0, absFilesEnd + 1) + `,\n    dependencies: [${depsArrayStr}]` + source.slice(absFilesEnd + 1);
+}
+
+function removeDependencies(source: string, name: string): string {
+    const namePos = findNamePos(source, name);
+    if (namePos === -1) return source;
+    const nextNamePos = source.indexOf('name: ', namePos + name.length + 8);
+    const blockEnd = nextNamePos === -1 ? source.length : nextNamePos;
+    const blockSlice = source.slice(namePos, blockEnd);
+
+    // Match leading comma + whitespace + dependencies: [...] but NOT trailing comma
+    const depsRegex = /,?\s*dependencies:\s*\[[\s\S]*?\]/;
+    const depsMatch = depsRegex.exec(blockSlice);
+    if (!depsMatch) return source;
+
+    const absStart = namePos + depsMatch.index;
+    const absEnd = absStart + depsMatch[0].length;
+    return source.slice(0, absStart) + source.slice(absEnd);
+}
+
+function applyUpdates(updates: ComponentUpdate[]): void {
+    let source = readFileSync(REGISTRY_PATH, 'utf-8');
+
+    for (const update of updates) {
+        const filesArrayStr = update.files.map(f => `'${f}'`).join(', ');
+        source = replaceFilesArray(source, update.name, filesArrayStr);
+
+        if (update.libFiles.length > 0) {
+            const libArrayStr = update.libFiles.map(f => `'${f}'`).join(', ');
+            source = updateLibFiles(source, update.name, libArrayStr);
+        }
+
+        if (update.dependencies.length > 0) {
+            const depsStr = update.dependencies.map(d => `'${d}'`).join(', ');
+            source = updateDependencies(source, update.name, depsStr);
+        } else {
+            source = removeDependencies(source, update.name);
+        }
+    }
+
+    writeFileSync(REGISTRY_PATH, source);
+    console.log('Registry updated.');
+}
+
+// ── Main ────────────────────────────────────────────────────────────────
+
+function main(): void {
+    const fix = process.argv.includes('--fix');
+    const entries = parseRegistry();
+    const entryFileToComponent = buildBoundaryMap(entries);
+
+    console.log(`Scanning ${entries.length} components...\n`);
+
+    let hasChanges = false;
+    const updates: ComponentUpdate[] = [];
+
+    for (const entry of entries) {
+        const { update, changed } = analyzeComponent(entry, entryFileToComponent);
+        if (changed) hasChanges = true;
+        updates.push(update);
+    }
+
+    if (!hasChanges) {
+        console.log('All components are in sync.');
+        return;
+    }
+
+    console.log('');
+
+    if (fix) {
+        applyUpdates(updates);
+    } else {
+        console.log('Run with --fix to update the registry.');
+        process.exitCode = 1;
+    }
+}
+
+main();

package/src/commands/add.spec.ts

@@ -7,9 +7,8 @@ import {
   checkFileConflict,
   classifyComponent,
   detectConflicts,
-  type AddOptions,
 } from './add.js';
-import { registry, type ComponentName, type ComponentDefinition } from '../registry/index.js';
+import { registry, type ComponentName } from '../registry/index.js';
 import fs from 'fs-extra';
 
 // ---------------------------------------------------------------------------
@@ -353,22 +352,22 @@ 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: string[] = ['compA', 'compB'];
-    const toOverwrite: string[] = ['compA'];
-    const finalComponents: string[] = ['compA'];
+    const conflicting = new Set(['compA', 'compB']);
+    const toOverwrite = new Set(['compA']);
+    const finalComponents = new Set(['compA']);
 
     const mockPeerFiles: Record<string, string[] | undefined> = {
       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 =>
+        const stillNeeded = [...finalComponents].some(fc =>
           mockPeerFiles[fc]?.includes(file),
         );
         if (!stillNeeded) {
@@ -384,22 +383,22 @@ 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: string[] = ['compA', 'compB'];
-    const toOverwrite: string[] = ['compA'];
-    const finalComponents: string[] = ['compA'];
+    const conflicting = new Set(['compA', 'compB']);
+    const toOverwrite = new Set(['compA']);
+    const finalComponents = new Set(['compA']);
 
     const mockPeerFiles: Record<string, string[] | undefined> = {
       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 =>
+        const stillNeeded = [...finalComponents].some(fc =>
           mockPeerFiles[fc]?.includes(file),
         );
         if (!stillNeeded) {
@@ -413,27 +412,18 @@ 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: string[] = ['compA', 'compB'];
-    const toOverwrite: string[] = [];
-    const finalComponents: string[] = [];
+    const declined = ['compA', 'compB'];
 
     const mockPeerFiles: Record<string, string[] | undefined> = {
       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);
       }
     }
 
@@ -468,9 +458,9 @@ describe('resolveDependencies', () => {
   });
 
   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');
 
@@ -547,25 +537,25 @@ describe('registry optional dependencies', () => {
   });
 
   it('every optional dependency name is a valid registry key', () => {
-    for (const [componentName, definition] of Object.entries(registry) as [string, ComponentDefinition][]) {
+    for (const [componentName, definition] of Object.entries(registry)) {
       if (!definition.optionalDependencies) continue;
       for (const opt of definition.optionalDependencies) {
         expect(
-          registry[opt.name],
+          opt.name in registry,
           `Optional dep "${opt.name}" in "${componentName}" is not a valid registry key`,
-        ).toBeDefined();
+        ).toBe(true);
       }
     }
   });
 
   it('every dependency name is a valid registry key', () => {
-    for (const [componentName, definition] of Object.entries(registry) as [string, ComponentDefinition][]) {
+    for (const [componentName, definition] of Object.entries(registry)) {
       if (!definition.dependencies) continue;
       for (const dep of definition.dependencies) {
         expect(
-          registry[dep],
+          dep in registry,
           `Dependency "${dep}" in "${componentName}" is not a valid registry key`,
-        ).toBeDefined();
+        ).toBe(true);
       }
     }
   });